aboutsummaryrefslogtreecommitdiff
path: root/test/validation/api/crypto/odp_crypto_test_inp.c
diff options
context:
space:
mode:
Diffstat (limited to 'test/validation/api/crypto/odp_crypto_test_inp.c')
-rw-r--r--test/validation/api/crypto/odp_crypto_test_inp.c1247
1 files changed, 81 insertions, 1166 deletions
diff --git a/test/validation/api/crypto/odp_crypto_test_inp.c b/test/validation/api/crypto/odp_crypto_test_inp.c
index c6a7767cc..d7e2bd16b 100644
--- a/test/validation/api/crypto/odp_crypto_test_inp.c
+++ b/test/validation/api/crypto/odp_crypto_test_inp.c
@@ -10,8 +10,10 @@
#include <odp_api.h>
#include <odp/helper/odph_api.h>
#include <odp_cunit_common.h>
-#include <packet_common.h>
#include "test_vectors.h"
+#include "test_vector_defs.h"
+#include "crypto_op_test.h"
+#include "util.h"
/*
* If nonzero, run time consuming tests too.
@@ -25,20 +27,6 @@ static int full_test;
#define PKT_POOL_LEN 1200 /* enough for a test packet and some headroom */
#define UAREA_SIZE 8
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
-
-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;
- odp_queue_type_t q_type;
- odp_event_t (*compl_queue_deq)(void);
-};
-
-static struct suite_context_s suite_context;
-
static void test_defaults(uint8_t fill)
{
odp_crypto_session_param_t param;
@@ -63,733 +51,14 @@ static void test_default_values(void)
test_defaults(0xff);
}
-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_SHA224_HMAC:
- return "ODP_AUTH_ALG_SHA224_HMAC";
- case ODP_AUTH_ALG_SHA256_HMAC:
- return "ODP_AUTH_ALG_SHA256_HMAC";
- case ODP_AUTH_ALG_SHA384_HMAC:
- return "ODP_AUTH_ALG_SHA384_HMAC";
- case ODP_AUTH_ALG_SHA512_HMAC:
- return "ODP_AUTH_ALG_SHA512_HMAC";
- case ODP_AUTH_ALG_AES_XCBC_MAC:
- return "ODP_AUTH_ALG_AES_XCBC_MAC";
- case ODP_AUTH_ALG_AES_GCM:
- return "ODP_AUTH_ALG_AES_GCM";
- case ODP_AUTH_ALG_AES_GMAC:
- return "ODP_AUTH_ALG_AES_GMAC";
- case ODP_AUTH_ALG_AES_CCM:
- return "ODP_AUTH_ALG_AES_CCM";
- case ODP_AUTH_ALG_AES_CMAC:
- return "ODP_AUTH_ALG_AES_CMAC";
- case ODP_AUTH_ALG_CHACHA20_POLY1305:
- return "ODP_AUTH_ALG_CHACHA20_POLY1305";
- case ODP_AUTH_ALG_KASUMI_F9:
- return "ODP_AUTH_ALG_KASUMI_F9";
- case ODP_AUTH_ALG_SNOW3G_UIA2:
- return "ODP_AUTH_ALG_SNOW3G_UIA2";
- case ODP_AUTH_ALG_AES_EIA2:
- return "ODP_AUTH_ALG_AES_EIA2";
- case ODP_AUTH_ALG_ZUC_EIA3:
- return "ODP_AUTH_ALG_ZUC_EIA3";
- case ODP_AUTH_ALG_MD5:
- return "ODP_AUTH_ALG_MD5";
- case ODP_AUTH_ALG_SHA1:
- return "ODP_AUTH_ALG_SHA1";
- case ODP_AUTH_ALG_SHA224:
- return "ODP_AUTH_ALG_SHA224";
- case ODP_AUTH_ALG_SHA256:
- return "ODP_AUTH_ALG_SHA256";
- case ODP_AUTH_ALG_SHA384:
- return "ODP_AUTH_ALG_SHA384";
- case ODP_AUTH_ALG_SHA512:
- return "ODP_AUTH_ALG_SHA512";
- 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_3DES_ECB:
- return "ODP_CIPHER_ALG_3DES_ECB";
- case ODP_CIPHER_ALG_AES_CBC:
- return "ODP_CIPHER_ALG_AES_CBC";
- case ODP_CIPHER_ALG_AES_CTR:
- return "ODP_CIPHER_ALG_AES_CTR";
- case ODP_CIPHER_ALG_AES_ECB:
- return "ODP_CIPHER_ALG_AES_ECB";
- case ODP_CIPHER_ALG_AES_CFB128:
- return "ODP_CIPHER_ALG_AES_CFB128";
- case ODP_CIPHER_ALG_AES_XTS:
- return "ODP_CIPHER_ALG_AES_XTS";
- case ODP_CIPHER_ALG_AES_GCM:
- return "ODP_CIPHER_ALG_AES_GCM";
- case ODP_CIPHER_ALG_AES_CCM:
- return "ODP_CIPHER_ALG_AES_CCM";
- case ODP_CIPHER_ALG_CHACHA20_POLY1305:
- return "ODP_CIPHER_ALG_CHACHA20_POLY1305";
- case ODP_CIPHER_ALG_KASUMI_F8:
- return "ODP_CIPHER_ALG_KASUMI_F8";
- case ODP_CIPHER_ALG_SNOW3G_UEA2:
- return "ODP_CIPHER_ALG_SNOW3G_UEA2";
- case ODP_CIPHER_ALG_AES_EEA2:
- return "ODP_CIPHER_ALG_AES_EEA2";
- case ODP_CIPHER_ALG_ZUC_EEA3:
- return "ODP_CIPHER_ALG_ZUC_EEA3";
- default:
- return "Unknown";
- }
-}
-
-static int alg_packet_op(odp_packet_t pkt_in,
- odp_packet_t *pkt_out,
- odp_bool_t *ok,
- odp_crypto_session_t session,
- odp_crypto_op_type_t op_type,
- int32_t oop_shift,
- uint8_t *cipher_iv_ptr,
- uint8_t *auth_iv_ptr,
- const odp_packet_data_range_t *cipher_range,
- const odp_packet_data_range_t *auth_range,
- uint8_t *aad,
- unsigned int hash_result_offset)
-{
- 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 orig_pkt_out;
-
- if (op_type == ODP_CRYPTO_OP_TYPE_LEGACY)
- *pkt_out = pkt_in;
- else if (op_type == ODP_CRYPTO_OP_TYPE_BASIC)
- *pkt_out = ODP_PACKET_INVALID;
- orig_pkt_out = *pkt_out;
-
- /* 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;
- op_params.dst_offset_shift = oop_shift;
- 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 = hash_result_offset;
-
- if (suite_context.op_mode == ODP_CRYPTO_SYNC) {
- rc = odp_crypto_op(&pkt_in, pkt_out, &op_params, 1);
- if (rc <= 0) {
- CU_FAIL("Failed odp_crypto_packet_op()");
- return rc;
- }
- } else {
- odp_packet_t *out_param = pkt_out;
-
- if (op_type == ODP_CRYPTO_OP_TYPE_BASIC)
- out_param = NULL;
-
- rc = odp_crypto_op_enq(&pkt_in, out_param, &op_params, 1);
- if (rc <= 0) {
- CU_FAIL("Failed odp_crypto_op_enq()");
- return rc;
- }
-
- /* Get crypto completion event from compl_queue. */
- CU_ASSERT_FATAL(NULL != suite_context.compl_queue_deq);
- do {
- event = suite_context.compl_queue_deq();
- } 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_out = odp_crypto_packet_from_event(event);
- }
-
- if (op_type != ODP_CRYPTO_OP_TYPE_BASIC)
- CU_ASSERT(*pkt_out == orig_pkt_out);
- CU_ASSERT(ODP_EVENT_PACKET ==
- odp_event_type(odp_packet_to_event(*pkt_out)));
- CU_ASSERT(ODP_EVENT_PACKET_CRYPTO ==
- odp_event_subtype(odp_packet_to_event(*pkt_out)));
- CU_ASSERT(ODP_EVENT_PACKET ==
- odp_event_types(odp_packet_to_event(*pkt_out), &subtype));
- CU_ASSERT(ODP_EVENT_PACKET_CRYPTO == subtype);
- CU_ASSERT(odp_packet_subtype(*pkt_out) == ODP_EVENT_PACKET_CRYPTO);
-
- rc = odp_crypto_result(&result, *pkt_out);
- if (rc < -1) {
- CU_FAIL("Failed odp_crypto_packet_result()");
- return rc;
- }
- CU_ASSERT(rc == 0 || rc == -1);
-
- if (op_type == ODP_CRYPTO_OP_TYPE_OOP &&
- suite_context.op_mode == ODP_CRYPTO_ASYNC)
- CU_ASSERT(result.pkt_in == pkt_in);
-
- *ok = (rc == 0);
-
-#if ODP_DEPRECATED_API
- CU_ASSERT(*ok == result.ok);
-#endif
-
- return 0;
-}
-
-static int crypto_op(odp_packet_t pkt_in,
- odp_packet_t *pkt_out,
- odp_bool_t *ok,
- odp_crypto_session_t session,
- odp_crypto_op_type_t op_type,
- int32_t oop_shift,
- uint8_t *cipher_iv,
- uint8_t *auth_iv,
- const odp_packet_data_range_t *cipher_range,
- const odp_packet_data_range_t *auth_range,
- uint8_t *aad,
- unsigned int hash_result_offset)
-{
- int rc;
-
- rc = alg_packet_op(pkt_in, pkt_out, ok, session,
- op_type, oop_shift,
- cipher_iv, auth_iv,
- cipher_range, auth_range,
- aad, hash_result_offset);
-
- if (rc < 0)
- odp_packet_free(pkt_in);
-
- return rc;
-}
-
-/*
- * Try to adjust packet so that the first segment holds 'first_seg_len' bytes
- * of packet data (+ tailroom if first_seg_len is longer than the packet).
- *
- * If 'first_seg_len' is zero, do not try to add segments but make headroom
- * zero.
- *
- * Packet data bytes are not preserved.
- */
-static void adjust_segments(odp_packet_t *pkt, uint32_t first_seg_len)
-{
- uint32_t shift;
-
- shift = odp_packet_headroom(*pkt) + first_seg_len;
-
- if (odp_packet_extend_head(pkt, shift, NULL, NULL) < 0) {
- CU_FAIL("odp_packet_extend_head() failed\n");
- return;
- }
- if (odp_packet_trunc_tail(pkt, shift, NULL, NULL) < 0) {
- CU_FAIL("odp_packet_trunc_tail() failed\n");
- return;
- }
- /*
- * ODP API does not seem to guarantee that we ever have a multi-segment
- * packet at this point, but we can print a message about it.
- */
- if (first_seg_len == 1 &&
- first_seg_len != odp_packet_seg_len(*pkt))
- printf("Could not create a segmented packet for testing.\n");
-}
-
-static void fill_with_pattern(uint8_t *buf, uint32_t len)
-{
- static uint8_t value;
-
- for (uint32_t n = 0; n < len; n++)
- buf[n] = value++;
-}
-
-static void write_header_and_trailer(odp_packet_t pkt,
- uint32_t header_len, uint32_t trailer_len)
-{
- uint32_t trailer_offset = odp_packet_len(pkt) - trailer_len;
- uint32_t max_len = header_len > trailer_len ? header_len : trailer_len;
- uint8_t buffer[max_len];
- int rc;
-
- fill_with_pattern(buffer, sizeof(buffer));
-
- rc = odp_packet_copy_from_mem(pkt, 0, header_len, buffer);
- CU_ASSERT(rc == 0);
- rc = odp_packet_copy_from_mem(pkt, trailer_offset, trailer_len, buffer);
- CU_ASSERT(rc == 0);
-}
-
-typedef struct alg_test_param_t {
- odp_crypto_session_t session;
- odp_crypto_op_t op;
- odp_crypto_op_type_t op_type;
- int32_t oop_shift;
- odp_cipher_alg_t cipher_alg;
- odp_auth_alg_t auth_alg;
- crypto_test_reference_t *ref;
- odp_packet_data_range_t cipher_range;
- odp_packet_data_range_t auth_range;
- uint32_t digest_offset;
- odp_bool_t is_bit_mode_cipher;
- odp_bool_t is_bit_mode_auth;
- odp_bool_t adjust_segmentation;
- odp_bool_t wrong_digest;
- uint32_t first_seg_len;
- uint32_t header_len;
- uint32_t trailer_len;
-} alg_test_param_t;
-
-static void prepare_crypto_ranges(const alg_test_param_t *param,
- odp_packet_data_range_t *cipher_range,
- odp_packet_data_range_t *auth_range)
-{
- odp_packet_data_range_t zero_range = {.offset = 0, .length = 0};
- uint32_t c_scale = param->is_bit_mode_cipher ? 8 : 1;
- uint32_t a_scale = param->is_bit_mode_auth ? 8 : 1;
-
- *cipher_range = param->cipher_range;
- *auth_range = param->auth_range;
- cipher_range->offset += c_scale * param->header_len;
- auth_range->offset += a_scale * param->header_len;
-
- if (param->cipher_alg == ODP_CIPHER_ALG_NULL)
- *cipher_range = zero_range;
- if (param->auth_alg == ODP_AUTH_ALG_NULL)
- *auth_range = zero_range;
-}
-
-static int prepare_input_packet(const alg_test_param_t *param,
- odp_packet_t *pkt_in)
-{
- crypto_test_reference_t *ref = param->ref;
- uint32_t reflength = ref_length_in_bytes(ref);
- odp_packet_t pkt;
- uint32_t digest_offset = param->digest_offset;
- uint32_t pkt_len;
-
- pkt_len = param->header_len + reflength + param->trailer_len;
- if (param->digest_offset == param->header_len + reflength)
- pkt_len += ref->digest_length;
-
- pkt = odp_packet_alloc(suite_context.pool, pkt_len);
-
- CU_ASSERT(pkt != ODP_PACKET_INVALID);
- if (pkt == ODP_PACKET_INVALID)
- return -1;
-
- if (param->adjust_segmentation)
- adjust_segments(&pkt, param->first_seg_len);
-
- write_header_and_trailer(pkt, param->header_len, param->trailer_len);
-
- if (param->op == ODP_CRYPTO_OP_ENCODE) {
- odp_packet_copy_from_mem(pkt, param->header_len,
- reflength, ref->plaintext);
- } else {
- odp_packet_copy_from_mem(pkt, param->header_len,
- reflength, ref->ciphertext);
- odp_packet_copy_from_mem(pkt, digest_offset,
- ref->digest_length,
- ref->digest);
- if (param->wrong_digest) {
- uint8_t byte = ~ref->digest[0];
-
- odp_packet_copy_from_mem(pkt, digest_offset, 1, &byte);
- }
- }
- *pkt_in = pkt;
- return 0;
-}
-
-static void prepare_oop_output_packet(const alg_test_param_t *param,
- odp_packet_t *pkt_out,
- uint32_t pkt_len)
+static void print_alg_test_param(const crypto_op_test_param_t *p)
{
- uint32_t reflength = ref_length_in_bytes(param->ref);
- const uint32_t oop_extra_len = 5;
- uint32_t trl_len;
- uint32_t hdr_len;
- uint32_t oop_len;
-
- oop_len = pkt_len + param->oop_shift + oop_extra_len;
- *pkt_out = odp_packet_alloc(suite_context.pool, oop_len);
- CU_ASSERT_FATAL(*pkt_out != ODP_PACKET_INVALID);
-
- uint8_t buf[oop_len];
-
- memset(buf, 0x55, sizeof(buf));
- odp_packet_copy_from_mem(*pkt_out, 0, sizeof(buf), buf);
-
- hdr_len = param->header_len + param->oop_shift;
- trl_len = oop_len - hdr_len - reflength;
-
- write_header_and_trailer(*pkt_out, hdr_len, trl_len);
-
- /* have different metadata than in the input packet */
- memset(odp_packet_user_area(*pkt_out), 0xab,
- odp_packet_user_area_size(*pkt_out));
-}
-
-static int is_packet_data_equal(odp_packet_t pkt_1, odp_packet_t pkt_2)
-{
- uint32_t len = odp_packet_len(pkt_1);
- uint8_t buf_1[len];
- uint8_t buf_2[len];
-
- if (len != odp_packet_len(pkt_2) ||
- odp_packet_copy_to_mem(pkt_1, 0, len, buf_1) ||
- odp_packet_copy_to_mem(pkt_2, 0, len, buf_2))
- return 0;
-
- return !memcmp(buf_1, buf_2, len);
-}
-
-static int is_in_range(uint32_t offs, uint32_t range_offs, uint32_t range_len)
-{
- return offs >= range_offs && offs < range_offs + range_len;
-}
-
-#define MAX_IGNORED_RANGES 3
-
-/*
- * Output packet parts that we ignore since they have undefined values
- */
-typedef struct ignore_t {
- uint32_t byte_offset; /* offset to a byte which has bits to be ignored */
- uint8_t byte_mask; /* mask of ignored bits in the byte */
- struct {
- uint32_t offset;
- uint32_t length;
- } ranges[MAX_IGNORED_RANGES]; /* byte ranges to be ignored */
- uint32_t num_ranges;
-} ignore_t;
-
-static void add_ignored_range(ignore_t *ign, uint32_t offs, uint32_t len)
-{
- if (len == 0)
- return;
- CU_ASSERT_FATAL(ign->num_ranges < MAX_IGNORED_RANGES);
- ign->ranges[ign->num_ranges].offset = offs;
- ign->ranges[ign->num_ranges].length = len;
- ign->num_ranges++;
-}
-
-static void clear_ignored_data(const ignore_t *ign, uint8_t *data, uint32_t data_len)
-{
- CU_ASSERT_FATAL(ign->byte_offset < data_len);
- data[ign->byte_offset] &= ~ign->byte_mask;
-
- for (uint32_t n = 0; n < ign->num_ranges; n++) {
- uint32_t offset = ign->ranges[n].offset;
- uint32_t length = ign->ranges[n].length;
-
- CU_ASSERT(offset + length <= data_len);
- memset(data + offset, 0, length);
- }
-}
-
-static void prepare_ignore_info(const alg_test_param_t *param,
- uint32_t shift,
- uint32_t cipher_offset,
- uint32_t cipher_len,
- uint32_t auth_offset,
- uint32_t auth_len,
- ignore_t *ignore)
-{
- memset(ignore, 0, sizeof(*ignore));
-
- /*
- * Leftover bits in the last byte of the cipher range of bit mode
- * ciphers have undefined values.
- */
- if (param->is_bit_mode_cipher &&
- param->cipher_alg != ODP_CIPHER_ALG_NULL) {
- uint8_t leftover_bits = ref_length_in_bits(param->ref) % 8;
-
- ignore->byte_offset = cipher_offset + cipher_len - 1 + shift;
- if (leftover_bits > 0)
- ignore->byte_mask = ~(0xff << (8 - leftover_bits));
- else
- ignore->byte_mask = 0;
- }
-
- /*
- * In decode sessions the bytes in the hash location have
- * undefined values.
- */
- if (param->auth_alg != ODP_AUTH_ALG_NULL &&
- param->op == ODP_CRYPTO_OP_DECODE) {
- uint32_t offs = param->digest_offset;
-
- if (param->op_type != ODP_CRYPTO_OP_TYPE_OOP ||
- is_in_range(offs, cipher_offset, cipher_len) ||
- is_in_range(offs, auth_offset, auth_len)) {
- add_ignored_range(ignore,
- param->digest_offset + shift,
- param->ref->digest_length);
- }
- }
-
- /* Decrypted bytes are undefined if authentication fails. */
- if (param->op == ODP_CRYPTO_OP_DECODE &&
- param->wrong_digest) {
- add_ignored_range(ignore, cipher_offset + shift, cipher_len);
- /* In OOP case, auth range may not get copied */
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP)
- add_ignored_range(ignore, auth_offset + shift, auth_len);
- }
-}
-
-/* Add room for bytes that are not included in ref->length */
-#define MAX_EXP_DATA_LEN (MAX_DATA_LEN + 200)
-
-/*
- * Expected packet data
- */
-typedef struct expected_t {
- uint8_t data[MAX_EXP_DATA_LEN];
- uint32_t len;
- ignore_t ignore;
-} expected_t;
-
-static void prepare_expected_data(const alg_test_param_t *param,
- const odp_packet_data_range_t *cipher_range,
- const odp_packet_data_range_t *auth_range,
- odp_packet_t pkt_in,
- odp_packet_t pkt_out,
- expected_t *ex)
-{
- uint32_t digest_offset = param->digest_offset;
- uint32_t cipher_offset = cipher_range->offset;
- uint32_t cipher_len = cipher_range->length;
- uint32_t auth_offset = auth_range->offset;
- uint32_t auth_len = auth_range->length;
- const int32_t shift = param->op_type == ODP_CRYPTO_OP_TYPE_OOP ? param->oop_shift : 0;
- const odp_packet_t base_pkt = param->op_type == ODP_CRYPTO_OP_TYPE_OOP ? pkt_out : pkt_in;
- int rc;
- uint32_t cipher_offset_in_ref = param->cipher_range.offset;
-
- if (param->op == ODP_CRYPTO_OP_ENCODE)
- digest_offset += shift;
-
- if (param->is_bit_mode_cipher) {
- cipher_offset_in_ref /= 8;
- cipher_offset /= 8;
- cipher_len = (cipher_len + 7) / 8;
- }
- if (param->is_bit_mode_auth) {
- auth_offset /= 8;
- auth_len = (auth_len + 7) / 8;
- }
- if (param->cipher_alg == ODP_CIPHER_ALG_NULL)
- cipher_len = 0;
- if (param->auth_alg == ODP_AUTH_ALG_NULL ||
- param->auth_alg == ODP_AUTH_ALG_AES_GCM ||
- param->auth_alg == ODP_AUTH_ALG_AES_CCM ||
- param->auth_alg == ODP_AUTH_ALG_CHACHA20_POLY1305) {
- /* auth range is ignored with null and AEAD algorithms */
- auth_len = 0;
- }
-
- /* copy all data from base packet */
- ex->len = odp_packet_len(base_pkt);
- CU_ASSERT_FATAL(ex->len <= sizeof(ex->data));
- rc = odp_packet_copy_to_mem(base_pkt, 0, ex->len, ex->data);
- CU_ASSERT(rc == 0);
-
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP && auth_len > 0) {
- /* copy auth range from input packet */
- rc = odp_packet_copy_to_mem(pkt_in, auth_offset, auth_len,
- ex->data + auth_offset + shift);
- CU_ASSERT(rc == 0);
- }
-
- if (param->op == ODP_CRYPTO_OP_ENCODE) {
- /* copy hash first */
- memcpy(ex->data + digest_offset,
- param->ref->digest,
- param->ref->digest_length);
- /*
- * Copy ciphertext, possibly overwriting hash.
- * The other order (hash overwriting some cipher
- * text) does not work in any real use case anyway.
- */
- memcpy(ex->data + cipher_offset + shift,
- param->ref->ciphertext + cipher_offset_in_ref,
- cipher_len);
- } else {
- memcpy(ex->data + cipher_offset + shift,
- param->ref->plaintext + cipher_offset_in_ref,
- cipher_len);
- }
-
- prepare_ignore_info(param, shift,
- cipher_offset, cipher_len,
- auth_offset, auth_len,
- &ex->ignore);
-}
-
-static void print_data(const char *title, uint8_t *data, uint32_t len)
-{
- static uint64_t limit;
-
- if (limit++ > MAX_FAILURE_PRINTS)
- return;
-
- printf("%s\n", title);
- for (uint32_t n = 0; n < len ; n++) {
- printf(" %02x", data[n]);
- if ((n + 1) % 16 == 0)
- printf("\n");
- }
- printf("\n");
-}
-
-static void check_output_packet_data(odp_packet_t pkt, expected_t *ex)
-{
- int rc;
- uint8_t pkt_data[ex->len];
-
- CU_ASSERT(odp_packet_len(pkt) == ex->len);
- rc = odp_packet_copy_to_mem(pkt, 0, ex->len, pkt_data);
- CU_ASSERT(rc == 0);
-
- clear_ignored_data(&ex->ignore, pkt_data, sizeof(pkt_data));
- clear_ignored_data(&ex->ignore, ex->data, sizeof(ex->data));
-
- if (memcmp(pkt_data, ex->data, ex->len)) {
- CU_FAIL("packet data does not match expected data");
- print_data("packet:", pkt_data, ex->len);
- print_data("expected:", ex->data, ex->len);
- }
-}
-
-static void alg_test_execute(const alg_test_param_t *param)
-{
- odp_bool_t ok = false;
- odp_packet_data_range_t cipher_range;
- odp_packet_data_range_t auth_range;
- odp_packet_t pkt;
- odp_packet_t pkt_copy = ODP_PACKET_INVALID;
- odp_packet_t pkt_out = ODP_PACKET_INVALID;
- uint32_t digest_offset = param->digest_offset;
- test_packet_md_t md_in, md_out, md_out_orig;
- expected_t expected;
-
- /*
- * Test detection of wrong digest value in input packet
- * only when decoding and using non-null auth algorithm.
- */
- if (param->wrong_digest &&
- (param->auth_alg == ODP_AUTH_ALG_NULL ||
- param->op == ODP_CRYPTO_OP_ENCODE))
- return;
-
- prepare_crypto_ranges(param, &cipher_range, &auth_range);
- if (prepare_input_packet(param, &pkt))
- return;
-
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP) {
- prepare_oop_output_packet(param, &pkt_out, odp_packet_len(pkt));
-
- pkt_copy = odp_packet_copy(pkt, suite_context.pool);
- CU_ASSERT_FATAL(pkt_copy != ODP_PACKET_INVALID);
- test_packet_get_md(pkt_out, &md_out_orig);
- }
-
- prepare_expected_data(param, &cipher_range, &auth_range,
- pkt, pkt_out, &expected);
-
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP &&
- param->op == ODP_CRYPTO_OP_ENCODE) {
- /*
- * In this type of sessions digest offset is an offset to the output
- * packet, so apply the shift.
- */
- digest_offset += param->oop_shift;
- }
-
- test_packet_set_md(pkt);
- test_packet_get_md(pkt, &md_in);
-
- if (crypto_op(pkt, &pkt_out, &ok, param->session,
- param->op_type, param->oop_shift,
- param->ref->cipher_iv,
- param->ref->auth_iv,
- &cipher_range, &auth_range,
- param->ref->aad, digest_offset))
- return;
-
- test_packet_get_md(pkt_out, &md_out);
+ const char *cipher_mode = p->is_bit_mode_cipher ? "bit" : "byte";
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP) {
- test_packet_md_t md;
- /* check that input packet has not changed */
- CU_ASSERT(is_packet_data_equal(pkt, pkt_copy));
- odp_packet_free(pkt_copy);
- test_packet_get_md(pkt, &md);
- CU_ASSERT(test_packet_is_md_equal(&md, &md_in));
- odp_packet_free(pkt);
- /* check that metadata of output packet has not changed */
- CU_ASSERT(test_packet_is_md_equal(&md_out, &md_out_orig));
- } else {
- CU_ASSERT(test_packet_is_md_equal(&md_out, &md_in));
- }
- if (param->cipher_alg != ODP_CIPHER_ALG_NULL &&
- param->auth_alg != ODP_AUTH_ALG_NULL &&
- param->digest_offset >= cipher_range.offset &&
- param->digest_offset < cipher_range.offset + cipher_range.length) {
- /*
- * Not all implementations support digest offset in cipher
- * range, so allow crypto op failure without further checks
- * in this case.
- */
- if (!ok)
- goto out;
- }
- if (param->wrong_digest) {
- CU_ASSERT(!ok);
- } else {
- CU_ASSERT(ok);
- }
- check_output_packet_data(pkt_out, &expected);
-out:
- odp_packet_free(pkt_out);
-}
-
-static void print_alg_test_param(const alg_test_param_t *p)
-{
- const char *cipher_mode = p->is_bit_mode_cipher ? "bit" : "byte";
const char *auth_mode = p->is_bit_mode_auth ? "bit" : "byte";
switch (p->op_type) {
@@ -805,13 +74,13 @@ static void print_alg_test_param(const alg_test_param_t *p)
}
printf("%s\n", p->op == ODP_CRYPTO_OP_ENCODE ? "encode" : "decode");
- printf("cipher: %s, %s mode\n", cipher_alg_name(p->cipher_alg), cipher_mode);
+ printf("cipher: %s, %s mode\n", cipher_alg_name(p->ref->cipher), cipher_mode);
printf(" key length: %d, iv length: %d\n",
p->ref->cipher_key_length, p->ref->cipher_iv_length);
printf(" range: offset %d, length %d\n",
p->cipher_range.offset, p->cipher_range.length);
- printf("auth: %s, %s mode\n", auth_alg_name(p->auth_alg), auth_mode);
+ printf("auth: %s, %s mode\n", auth_alg_name(p->ref->auth), auth_mode);
printf(" key length: %d, iv length: %d\n",
p->ref->auth_key_length, p->ref->auth_iv_length);
printf(" range: offset %d, length %d; aad length: %d\n",
@@ -828,12 +97,12 @@ static void print_alg_test_param(const alg_test_param_t *p)
printf("oop_shift: %d\n", p->oop_shift);
}
-static void alg_test_execute_and_print(alg_test_param_t *param)
+static void alg_test_execute_and_print(crypto_op_test_param_t *param)
{
static int print_limit = MAX_FAILURE_PRINTS;
unsigned int num = CU_get_number_of_failures();
- alg_test_execute(param);
+ test_crypto_op(param);
if (CU_get_number_of_failures() > num) {
if (print_limit > 0) {
@@ -847,7 +116,7 @@ static void alg_test_execute_and_print(alg_test_param_t *param)
}
}
-static void alg_test_op(alg_test_param_t *param)
+static void alg_test_op(crypto_op_test_param_t *param)
{
int32_t oop_shifts[] = {0, 3, 130, -10};
@@ -883,8 +152,6 @@ typedef enum {
static odp_crypto_session_t session_create(odp_crypto_op_t op,
odp_crypto_op_type_t op_type,
- odp_cipher_alg_t cipher_alg,
- odp_auth_alg_t auth_alg,
alg_order_t order,
crypto_test_reference_t *ref,
hash_test_mode_t hash_mode)
@@ -913,8 +180,8 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
ses_params.op_type = op_type;
ses_params.auth_cipher_text = (order == AUTH_CIPHERTEXT);
ses_params.op_mode = suite_context.op_mode;
- ses_params.cipher_alg = cipher_alg;
- ses_params.auth_alg = auth_alg;
+ ses_params.cipher_alg = ref->cipher;
+ ses_params.auth_alg = ref->auth;
ses_params.compl_queue = suite_context.queue;
ses_params.output_pool = suite_context.pool;
ses_params.cipher_key = cipher_key;
@@ -930,8 +197,8 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
if (!combo_warning_shown) {
combo_warning_shown = 1;
printf("\n Unsupported algorithm combination: %s, %s\n",
- cipher_alg_name(cipher_alg),
- auth_alg_name(auth_alg));
+ cipher_alg_name(ref->cipher),
+ auth_alg_name(ref->auth));
}
return ODP_CRYPTO_SESSION_INVALID;
}
@@ -944,8 +211,8 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
if (rc < 0 && status == ODP_CRYPTO_SES_ERR_ALG_ORDER &&
ses_params.op_mode == ODP_CRYPTO_ASYNC) {
printf("\n Unsupported algorithm order: %s, %s, auth_cipher_text: %d\n",
- cipher_alg_name(cipher_alg),
- auth_alg_name(auth_alg),
+ cipher_alg_name(ref->cipher),
+ auth_alg_name(ref->auth),
ses_params.auth_cipher_text);
return ODP_CRYPTO_SESSION_INVALID;
}
@@ -977,8 +244,6 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
static void alg_test_ses(odp_crypto_op_t op,
odp_crypto_op_type_t op_type,
- odp_cipher_alg_t cipher_alg,
- odp_auth_alg_t auth_alg,
alg_order_t order,
crypto_test_reference_t *ref,
odp_packet_data_range_t cipher_range,
@@ -994,13 +259,13 @@ static void alg_test_ses(odp_crypto_op_t op,
int rc;
uint32_t seg_len;
uint32_t max_shift;
- alg_test_param_t test_param;
+ crypto_op_test_param_t test_param;
if (digest_offset >= auth_range.offset &&
digest_offset < auth_range.offset + auth_range.length)
hash_mode = HASH_OVERLAP;
- session = session_create(op, op_type, cipher_alg, auth_alg, order, ref, hash_mode);
+ session = session_create(op, op_type, order, ref, hash_mode);
if (session == ODP_CRYPTO_SESSION_INVALID)
return;
@@ -1008,8 +273,6 @@ static void alg_test_ses(odp_crypto_op_t op,
test_param.session = session;
test_param.op = op;
test_param.op_type = op_type;
- test_param.cipher_alg = cipher_alg;
- test_param.auth_alg = auth_alg;
test_param.ref = ref;
test_param.cipher_range = cipher_range;
test_param.auth_range = auth_range;
@@ -1023,8 +286,8 @@ static void alg_test_ses(odp_crypto_op_t op,
seg_len = 0;
if (!full_test &&
- cipher_alg != ODP_CIPHER_ALG_NULL &&
- auth_alg != ODP_AUTH_ALG_NULL) {
+ ref->cipher != ODP_CIPHER_ALG_NULL &&
+ ref->auth != ODP_AUTH_ALG_NULL) {
/* run the loop body just once */
seg_len = max_shift / 2;
max_shift = seg_len;
@@ -1061,8 +324,6 @@ static void alg_test_ses(odp_crypto_op_t op,
}
static void alg_test(odp_crypto_op_t op,
- odp_cipher_alg_t cipher_alg,
- odp_auth_alg_t auth_alg,
alg_order_t order,
crypto_test_reference_t *ref,
odp_packet_data_range_t cipher_range,
@@ -1078,13 +339,8 @@ static void alg_test(odp_crypto_op_t op,
};
for (unsigned int n = 0; n < ARRAY_SIZE(op_types); n++) {
- if (!suite_context.packet &&
- op_types[n] != ODP_CRYPTO_OP_TYPE_LEGACY)
- continue;
alg_test_ses(op,
op_types[n],
- cipher_alg,
- auth_alg,
order,
ref,
cipher_range,
@@ -1109,12 +365,12 @@ static odp_bool_t aad_len_ok(const odp_crypto_auth_capability_t *capa, uint32_t
}
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)
{
int rc, i;
+ const odp_cipher_alg_t cipher_alg = ref->cipher;
+ const odp_auth_alg_t auth_alg = ref->auth;
int cipher_num = odp_crypto_cipher_capability(cipher_alg, NULL, 0);
int auth_num = odp_crypto_auth_capability(auth_alg, NULL, 0);
odp_bool_t cipher_ok = false;
@@ -1216,10 +472,10 @@ static void check_alg(odp_crypto_op_t op,
ref_length_in_bits(&ref[idx]) :
ref_length_in_bytes(&ref[idx]);
- alg_test(op, cipher_alg, auth_alg, AUTH_PLAINTEXT, &ref[idx],
+ alg_test(op, AUTH_PLAINTEXT, &ref[idx],
cipher_range, auth_range, digest_offs,
is_bit_mode_cipher, is_bit_mode_auth);
- alg_test(op, cipher_alg, auth_alg, AUTH_CIPHERTEXT, &ref[idx],
+ alg_test(op, AUTH_CIPHERTEXT, &ref[idx],
cipher_range, auth_range, digest_offs,
is_bit_mode_cipher, is_bit_mode_auth);
@@ -1254,214 +510,6 @@ static void check_alg(odp_crypto_op_t op,
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;
-
- memset(&capability, 0, sizeof(odp_crypto_capability_t));
- if (odp_crypto_capability(&capability)) {
- fprintf(stderr, "odp_crypto_capability() failed\n");
- return ODP_TEST_INACTIVE;
- }
-
- if (suite_context.queue != ODP_QUEUE_INVALID) {
- if (suite_context.q_type == ODP_QUEUE_TYPE_PLAIN &&
- capability.queue_type_plain == 0)
- return ODP_TEST_INACTIVE;
- if (suite_context.q_type == ODP_QUEUE_TYPE_SCHED &&
- capability.queue_type_sched == 0)
- return ODP_TEST_INACTIVE;
- }
-
- 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_3DES_ECB:
- if (!capability.ciphers.bit.trides_ecb)
- 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_ECB:
- if (!capability.ciphers.bit.aes_ecb)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_AES_CFB128:
- if (!capability.ciphers.bit.aes_cfb128)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_AES_XTS:
- if (!capability.ciphers.bit.aes_xts)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_AES_GCM:
- if (!capability.ciphers.bit.aes_gcm)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_AES_CCM:
- if (!capability.ciphers.bit.aes_ccm)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_CHACHA20_POLY1305:
- if (!capability.ciphers.bit.chacha20_poly1305)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_KASUMI_F8:
- if (!capability.ciphers.bit.kasumi_f8)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_SNOW3G_UEA2:
- if (!capability.ciphers.bit.snow3g_uea2)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_AES_EEA2:
- if (!capability.ciphers.bit.aes_eea2)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_CIPHER_ALG_ZUC_EEA3:
- if (!capability.ciphers.bit.zuc_eea3)
- 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_SHA224_HMAC:
- if (!capability.auths.bit.sha224_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_SHA384_HMAC:
- if (!capability.auths.bit.sha384_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_XCBC_MAC:
- if (!capability.auths.bit.aes_xcbc_mac)
- 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;
- case ODP_AUTH_ALG_AES_CCM:
- if (!capability.auths.bit.aes_ccm)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_AES_CMAC:
- if (!capability.auths.bit.aes_cmac)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_CHACHA20_POLY1305:
- if (!capability.auths.bit.chacha20_poly1305)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_KASUMI_F9:
- if (!capability.auths.bit.kasumi_f9)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SNOW3G_UIA2:
- if (!capability.auths.bit.snow3g_uia2)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_AES_EIA2:
- if (!capability.auths.bit.aes_eia2)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_ZUC_EIA3:
- if (!capability.auths.bit.zuc_eia3)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_MD5:
- if (!capability.auths.bit.md5)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SHA1:
- if (!capability.auths.bit.sha1)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SHA224:
- if (!capability.auths.bit.sha224)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SHA256:
- if (!capability.auths.bit.sha256)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SHA384:
- if (!capability.auths.bit.sha384)
- return ODP_TEST_INACTIVE;
- break;
- case ODP_AUTH_ALG_SHA512:
- if (!capability.auths.bit.sha512)
- return ODP_TEST_INACTIVE;
- break;
- default:
- fprintf(stderr, "Unsupported authentication algorithm\n");
- return ODP_TEST_INACTIVE;
- }
-
- return ODP_TEST_ACTIVE;
-}
-
static void test_capability(void)
{
odp_crypto_capability_t capa = {.max_sessions = 1};
@@ -1495,15 +543,14 @@ static int create_hash_test_reference(odp_auth_alg_t auth,
odp_bool_t ok;
const uint32_t auth_bytes = 100;
uint32_t enc_digest_offset = auth_bytes;
- odp_packet_data_range_t cipher_range = {.offset = 0, .length = 0};
- odp_packet_data_range_t auth_range = {.offset = 0};
+ ref->cipher = ODP_CIPHER_ALG_NULL;
+ ref->auth = auth;
ref->auth_key_length = capa->key_len;
ref->auth_iv_length = capa->iv_len;
ref->digest_length = capa->digest_len;
ref->is_length_in_bits = false;
ref->length = auth_bytes;
- auth_range.length = capa->bit_mode ? auth_bytes * 8 : auth_bytes;
if (ref->auth_key_length > MAX_KEY_LEN ||
ref->auth_iv_length > MAX_IV_LEN ||
@@ -1525,15 +572,28 @@ static int create_hash_test_reference(odp_auth_alg_t auth,
session = session_create(ODP_CRYPTO_OP_ENCODE,
ODP_CRYPTO_OP_TYPE_LEGACY,
- ODP_CIPHER_ALG_NULL,
- auth, AUTH_PLAINTEXT, ref, HASH_NO_OVERLAP);
+ AUTH_PLAINTEXT, ref, HASH_NO_OVERLAP);
if (session == ODP_CRYPTO_SESSION_INVALID)
return -1;
- rc = crypto_op(pkt, &pkt, &ok, session, ODP_CRYPTO_OP_TYPE_LEGACY, 0,
- ref->cipher_iv, ref->auth_iv,
- &cipher_range, &auth_range, ref->aad, enc_digest_offset);
+ odp_crypto_packet_op_param_t op_params = {
+ .session = session,
+ .cipher_iv_ptr = ref->cipher_iv,
+ .auth_iv_ptr = ref->auth_iv,
+ .hash_result_offset = enc_digest_offset,
+ .aad_ptr = ref->aad,
+ .cipher_range = {.offset = 0, .length = 0},
+ .auth_range = { .offset = 0,
+ .length = capa->bit_mode ? auth_bytes * 8 : auth_bytes },
+ .dst_offset_shift = 0,
+ };
+ rc = crypto_op(pkt, &pkt, &ok, &op_params, ODP_CRYPTO_OP_TYPE_LEGACY);
+
CU_ASSERT(rc == 0);
+ if (rc) {
+ (void)odp_crypto_session_destroy(session);
+ return -1;
+ }
CU_ASSERT(ok);
rc = odp_crypto_session_destroy(session);
@@ -1590,8 +650,6 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth,
* hash bytes in the ciphertext packet before calculating the hash.
*/
alg_test(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- auth,
order,
&ref,
cipher_range, auth_range,
@@ -1619,8 +677,6 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth,
* the hash bytes in the plaintext packet before calculating the hash.
*/
alg_test(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- auth,
order,
&ref,
cipher_range, auth_range,
@@ -1700,8 +756,6 @@ static void test_auth_hashes_in_auth_range(void)
* Encode ref->plaintext and save result in ref->ciphertext.
*/
static int crypto_encode_ref(crypto_test_reference_t *ref,
- odp_cipher_alg_t cipher,
- odp_auth_alg_t auth,
odp_packet_data_range_t cipher_range,
odp_packet_data_range_t auth_range,
uint32_t hash_result_offset)
@@ -1720,8 +774,6 @@ static int crypto_encode_ref(crypto_test_reference_t *ref,
session = session_create(ODP_CRYPTO_OP_ENCODE,
ODP_CRYPTO_OP_TYPE_LEGACY,
- cipher,
- auth,
AUTH_PLAINTEXT,
ref,
HASH_OVERLAP);
@@ -1731,20 +783,31 @@ static int crypto_encode_ref(crypto_test_reference_t *ref,
return 1;
}
- if (cipher == ODP_CIPHER_ALG_NULL)
+ if (ref->cipher == ODP_CIPHER_ALG_NULL)
cipher_range = zero_range;
- if (auth == ODP_AUTH_ALG_NULL) {
+ if (ref->auth == ODP_AUTH_ALG_NULL) {
auth_range = zero_range;
hash_result_offset = 0;
}
CU_ASSERT_FATAL(hash_result_offset + ref->digest_length <= ref->length);
- rc = crypto_op(pkt, &pkt, &ok, session, ODP_CRYPTO_OP_TYPE_LEGACY, 0,
- ref->cipher_iv, ref->auth_iv,
- &cipher_range, &auth_range,
- ref->aad, hash_result_offset);
+ odp_crypto_packet_op_param_t op_params = {
+ .session = session,
+ .cipher_iv_ptr = ref->cipher_iv,
+ .auth_iv_ptr = ref->auth_iv,
+ .hash_result_offset = hash_result_offset,
+ .aad_ptr = ref->aad,
+ .cipher_range = cipher_range,
+ .auth_range = auth_range,
+ .dst_offset_shift = 0,
+ };
+ rc = crypto_op(pkt, &pkt, &ok, &op_params, ODP_CRYPTO_OP_TYPE_LEGACY);
CU_ASSERT(rc == 0);
+ if (rc) {
+ (void)odp_crypto_session_destroy(session);
+ return -1;
+ }
CU_ASSERT(ok);
rc = odp_crypto_session_destroy(session);
@@ -1780,8 +843,6 @@ static int create_combined_ref(const crypto_suite_t *suite,
crypto_test_reference_t ref_cipher_only;
crypto_test_reference_t ref_auth_only;
crypto_test_reference_t *first_ref, *second_ref;
- odp_auth_alg_t first_auth, second_auth;
- odp_cipher_alg_t first_cipher, second_cipher;
total_len = cipher_range->offset + cipher_range->length;
if (auth_range->offset + auth_range->length > total_len)
@@ -1789,6 +850,8 @@ static int create_combined_ref(const crypto_suite_t *suite,
if (digest_offset + suite->auth_capa->digest_len > total_len)
total_len = digest_offset + suite->auth_capa->digest_len;
+ ref->cipher = suite->cipher;
+ ref->auth = suite->auth;
ref->cipher_key_length = suite->cipher_capa->key_len;
ref->cipher_iv_length = suite->cipher_capa->iv_len;
ref->auth_key_length = suite->auth_capa->key_len;
@@ -1821,39 +884,31 @@ static int create_combined_ref(const crypto_suite_t *suite,
memset(ref->plaintext + digest_offset, 0, ref->digest_length);
ref_cipher_only = *ref;
+ ref_cipher_only.auth = ODP_AUTH_ALG_NULL;
ref_cipher_only.auth_key_length = 0;
ref_cipher_only.auth_iv_length = 0;
ref_cipher_only.aad_length = 0;
ref_cipher_only.digest_length = 0;
ref_auth_only = *ref;
+ ref_auth_only.cipher = ODP_CIPHER_ALG_NULL;
ref_auth_only.cipher_key_length = 0;
ref_auth_only.cipher_iv_length = 0;
if (suite->order == AUTH_CIPHERTEXT) {
first_ref = &ref_cipher_only;
- first_cipher = suite->cipher;
- first_auth = ODP_AUTH_ALG_NULL;
second_ref = &ref_auth_only;
- second_cipher = ODP_CIPHER_ALG_NULL;
- second_auth = suite->auth;
} else {
first_ref = &ref_auth_only;
- first_cipher = ODP_CIPHER_ALG_NULL;
- first_auth = suite->auth;
second_ref = &ref_cipher_only;
- second_cipher = suite->cipher;
- second_auth = ODP_AUTH_ALG_NULL;
}
rc = crypto_encode_ref(first_ref,
- first_cipher, first_auth,
*cipher_range, *auth_range,
digest_offset);
if (rc)
return 1;
memcpy(second_ref->plaintext, first_ref->ciphertext, ref->length);
rc = crypto_encode_ref(second_ref,
- second_cipher, second_auth,
*cipher_range, *auth_range,
digest_offset);
if (rc)
@@ -2135,8 +1190,6 @@ static void test_combo(const crypto_suite_t *suite,
return;
alg_test(ODP_CRYPTO_OP_ENCODE,
- suite->cipher,
- suite->auth,
suite->order,
&ref,
cipher_range, auth_range,
@@ -2145,8 +1198,6 @@ static void test_combo(const crypto_suite_t *suite,
suite->auth_capa->bit_mode);
alg_test(ODP_CRYPTO_OP_DECODE,
- suite->cipher,
- suite->auth,
suite->order,
&ref,
cipher_range, auth_range,
@@ -2238,8 +1289,6 @@ static int check_alg_null(void)
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));
}
@@ -2247,8 +1296,6 @@ static void crypto_test_enc_alg_null(void)
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));
}
@@ -2261,8 +1308,6 @@ static int check_alg_3des_cbc(void)
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));
}
@@ -2270,8 +1315,6 @@ static void crypto_test_enc_alg_3des_cbc(void)
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));
}
@@ -2284,8 +1327,6 @@ static int check_alg_3des_ecb(void)
static void crypto_test_enc_alg_3des_ecb(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_3DES_ECB,
- ODP_AUTH_ALG_NULL,
tdes_ecb_reference,
ARRAY_SIZE(tdes_ecb_reference));
}
@@ -2293,8 +1334,6 @@ static void crypto_test_enc_alg_3des_ecb(void)
static void crypto_test_dec_alg_3des_ecb(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_3DES_ECB,
- ODP_AUTH_ALG_NULL,
tdes_ecb_reference,
ARRAY_SIZE(tdes_ecb_reference));
}
@@ -2308,8 +1347,6 @@ static int check_alg_chacha20_poly1305(void)
static void crypto_test_enc_alg_chacha20_poly1305(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_CHACHA20_POLY1305,
- ODP_AUTH_ALG_CHACHA20_POLY1305,
chacha20_poly1305_reference,
ARRAY_SIZE(chacha20_poly1305_reference));
}
@@ -2317,8 +1354,6 @@ static void crypto_test_enc_alg_chacha20_poly1305(void)
static void crypto_test_dec_alg_chacha20_poly1305(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_CHACHA20_POLY1305,
- ODP_AUTH_ALG_CHACHA20_POLY1305,
chacha20_poly1305_reference,
ARRAY_SIZE(chacha20_poly1305_reference));
}
@@ -2331,8 +1366,6 @@ static int check_alg_aes_gcm(void)
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));
}
@@ -2340,8 +1373,6 @@ static void crypto_test_enc_alg_aes_gcm(void)
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));
}
@@ -2354,8 +1385,6 @@ static int check_alg_aes_ccm(void)
static void crypto_test_enc_alg_aes_ccm(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_CCM,
- ODP_AUTH_ALG_AES_CCM,
aes_ccm_reference,
ARRAY_SIZE(aes_ccm_reference));
}
@@ -2363,8 +1392,6 @@ static void crypto_test_enc_alg_aes_ccm(void)
static void crypto_test_dec_alg_aes_ccm(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_CCM,
- ODP_AUTH_ALG_AES_CCM,
aes_ccm_reference,
ARRAY_SIZE(aes_ccm_reference));
}
@@ -2377,8 +1404,6 @@ static int check_alg_aes_cbc(void)
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));
}
@@ -2386,8 +1411,6 @@ static void crypto_test_enc_alg_aes_cbc(void)
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));
}
@@ -2400,8 +1423,6 @@ static int check_alg_aes_ctr(void)
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));
}
@@ -2409,8 +1430,6 @@ static void crypto_test_enc_alg_aes_ctr(void)
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));
}
@@ -2423,8 +1442,6 @@ static int check_alg_aes_ecb(void)
static void crypto_test_enc_alg_aes_ecb(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_ECB,
- ODP_AUTH_ALG_NULL,
aes_ecb_reference,
ARRAY_SIZE(aes_ecb_reference));
}
@@ -2432,8 +1449,6 @@ static void crypto_test_enc_alg_aes_ecb(void)
static void crypto_test_dec_alg_aes_ecb(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_ECB,
- ODP_AUTH_ALG_NULL,
aes_ecb_reference,
ARRAY_SIZE(aes_ecb_reference));
}
@@ -2446,8 +1461,6 @@ static int check_alg_aes_cfb128(void)
static void crypto_test_enc_alg_aes_cfb128(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_CFB128,
- ODP_AUTH_ALG_NULL,
aes_cfb128_reference,
ARRAY_SIZE(aes_cfb128_reference));
}
@@ -2455,8 +1468,6 @@ static void crypto_test_enc_alg_aes_cfb128(void)
static void crypto_test_dec_alg_aes_cfb128(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_CFB128,
- ODP_AUTH_ALG_NULL,
aes_cfb128_reference,
ARRAY_SIZE(aes_cfb128_reference));
}
@@ -2469,8 +1480,6 @@ static int check_alg_aes_xts(void)
static void crypto_test_enc_alg_aes_xts(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_XTS,
- ODP_AUTH_ALG_NULL,
aes_xts_reference,
ARRAY_SIZE(aes_xts_reference));
}
@@ -2478,8 +1487,6 @@ static void crypto_test_enc_alg_aes_xts(void)
static void crypto_test_dec_alg_aes_xts(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_XTS,
- ODP_AUTH_ALG_NULL,
aes_xts_reference,
ARRAY_SIZE(aes_xts_reference));
}
@@ -2492,8 +1499,6 @@ static int check_alg_kasumi_f8(void)
static void crypto_test_enc_alg_kasumi_f8(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_KASUMI_F8,
- ODP_AUTH_ALG_NULL,
kasumi_f8_reference,
ARRAY_SIZE(kasumi_f8_reference));
}
@@ -2501,8 +1506,6 @@ static void crypto_test_enc_alg_kasumi_f8(void)
static void crypto_test_dec_alg_kasumi_f8(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_KASUMI_F8,
- ODP_AUTH_ALG_NULL,
kasumi_f8_reference,
ARRAY_SIZE(kasumi_f8_reference));
}
@@ -2515,8 +1518,6 @@ static int check_alg_snow3g_uea2(void)
static void crypto_test_enc_alg_snow3g_uea2(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_SNOW3G_UEA2,
- ODP_AUTH_ALG_NULL,
snow3g_uea2_reference,
ARRAY_SIZE(snow3g_uea2_reference));
}
@@ -2524,8 +1525,6 @@ static void crypto_test_enc_alg_snow3g_uea2(void)
static void crypto_test_dec_alg_snow3g_uea2(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_SNOW3G_UEA2,
- ODP_AUTH_ALG_NULL,
snow3g_uea2_reference,
ARRAY_SIZE(snow3g_uea2_reference));
}
@@ -2539,8 +1538,6 @@ static int check_alg_aes_eea2(void)
static void crypto_test_enc_alg_aes_eea2(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_AES_EEA2,
- ODP_AUTH_ALG_NULL,
aes_eea2_reference,
ARRAY_SIZE(aes_eea2_reference));
}
@@ -2548,8 +1545,6 @@ static void crypto_test_enc_alg_aes_eea2(void)
static void crypto_test_dec_alg_aes_eea2(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_AES_EEA2,
- ODP_AUTH_ALG_NULL,
aes_eea2_reference,
ARRAY_SIZE(aes_eea2_reference));
}
@@ -2562,8 +1557,6 @@ static int check_alg_zuc_eea3(void)
static void crypto_test_enc_alg_zuc_eea3(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_ZUC_EEA3,
- ODP_AUTH_ALG_NULL,
zuc_eea3_reference,
ARRAY_SIZE(zuc_eea3_reference));
}
@@ -2571,8 +1564,6 @@ static void crypto_test_enc_alg_zuc_eea3(void)
static void crypto_test_dec_alg_zuc_eea3(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_ZUC_EEA3,
- ODP_AUTH_ALG_NULL,
zuc_eea3_reference,
ARRAY_SIZE(zuc_eea3_reference));
}
@@ -2585,8 +1576,6 @@ static int check_alg_hmac_md5(void)
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));
}
@@ -2594,8 +1583,6 @@ static void crypto_test_gen_alg_hmac_md5(void)
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));
}
@@ -2608,8 +1595,6 @@ static int check_alg_hmac_sha1(void)
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));
}
@@ -2617,8 +1602,6 @@ static void crypto_test_gen_alg_hmac_sha1(void)
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));
}
@@ -2631,8 +1614,6 @@ static int check_alg_hmac_sha224(void)
static void crypto_test_gen_alg_hmac_sha224(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA224_HMAC,
hmac_sha224_reference,
ARRAY_SIZE(hmac_sha224_reference));
}
@@ -2640,8 +1621,6 @@ static void crypto_test_gen_alg_hmac_sha224(void)
static void crypto_test_check_alg_hmac_sha224(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA224_HMAC,
hmac_sha224_reference,
ARRAY_SIZE(hmac_sha224_reference));
}
@@ -2654,8 +1633,6 @@ static int check_alg_hmac_sha256(void)
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));
}
@@ -2663,8 +1640,6 @@ static void crypto_test_gen_alg_hmac_sha256(void)
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));
}
@@ -2677,8 +1652,6 @@ static int check_alg_hmac_sha384(void)
static void crypto_test_gen_alg_hmac_sha384(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA384_HMAC,
hmac_sha384_reference,
ARRAY_SIZE(hmac_sha384_reference));
}
@@ -2686,8 +1659,6 @@ static void crypto_test_gen_alg_hmac_sha384(void)
static void crypto_test_check_alg_hmac_sha384(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA384_HMAC,
hmac_sha384_reference,
ARRAY_SIZE(hmac_sha384_reference));
}
@@ -2700,8 +1671,6 @@ static int check_alg_hmac_sha512(void)
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));
}
@@ -2709,8 +1678,6 @@ static void crypto_test_gen_alg_hmac_sha512(void)
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));
}
@@ -2724,8 +1691,6 @@ static int check_alg_aes_xcbc(void)
static void crypto_test_gen_alg_aes_xcbc(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_XCBC_MAC,
aes_xcbc_reference,
ARRAY_SIZE(aes_xcbc_reference));
}
@@ -2733,8 +1698,6 @@ static void crypto_test_gen_alg_aes_xcbc(void)
static void crypto_test_check_alg_aes_xcbc(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_XCBC_MAC,
aes_xcbc_reference,
ARRAY_SIZE(aes_xcbc_reference));
}
@@ -2747,8 +1710,6 @@ static int check_alg_aes_gmac(void)
static void crypto_test_gen_alg_aes_gmac(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_GMAC,
aes_gmac_reference,
ARRAY_SIZE(aes_gmac_reference));
}
@@ -2756,8 +1717,6 @@ static void crypto_test_gen_alg_aes_gmac(void)
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));
}
@@ -2770,8 +1729,6 @@ static int check_alg_aes_cmac(void)
static void crypto_test_gen_alg_aes_cmac(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_CMAC,
aes_cmac_reference,
ARRAY_SIZE(aes_cmac_reference));
}
@@ -2779,8 +1736,6 @@ static void crypto_test_gen_alg_aes_cmac(void)
static void crypto_test_check_alg_aes_cmac(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_CMAC,
aes_cmac_reference,
ARRAY_SIZE(aes_cmac_reference));
}
@@ -2793,8 +1748,6 @@ static int check_alg_kasumi_f9(void)
static void crypto_test_gen_alg_kasumi_f9(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_KASUMI_F9,
kasumi_f9_reference,
ARRAY_SIZE(kasumi_f9_reference));
}
@@ -2802,8 +1755,6 @@ static void crypto_test_gen_alg_kasumi_f9(void)
static void crypto_test_check_alg_kasumi_f9(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_KASUMI_F9,
kasumi_f9_reference,
ARRAY_SIZE(kasumi_f9_reference));
}
@@ -2816,8 +1767,6 @@ static int check_alg_snow3g_uia2(void)
static void crypto_test_gen_alg_snow3g_uia2(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SNOW3G_UIA2,
snow3g_uia2_reference,
ARRAY_SIZE(snow3g_uia2_reference));
}
@@ -2825,8 +1774,6 @@ static void crypto_test_gen_alg_snow3g_uia2(void)
static void crypto_test_check_alg_snow3g_uia2(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SNOW3G_UIA2,
snow3g_uia2_reference,
ARRAY_SIZE(snow3g_uia2_reference));
}
@@ -2840,8 +1787,6 @@ static int check_alg_aes_eia2(void)
static void crypto_test_gen_alg_aes_eia2(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_EIA2,
aes_eia2_reference,
ARRAY_SIZE(aes_eia2_reference));
}
@@ -2849,8 +1794,6 @@ static void crypto_test_gen_alg_aes_eia2(void)
static void crypto_test_check_alg_aes_eia2(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_AES_EIA2,
aes_eia2_reference,
ARRAY_SIZE(aes_eia2_reference));
}
@@ -2863,8 +1806,6 @@ static int check_alg_zuc_eia3(void)
static void crypto_test_gen_alg_zuc_eia3(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_ZUC_EIA3,
zuc_eia3_reference,
ARRAY_SIZE(zuc_eia3_reference));
}
@@ -2872,8 +1813,6 @@ static void crypto_test_gen_alg_zuc_eia3(void)
static void crypto_test_check_alg_zuc_eia3(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_ZUC_EIA3,
zuc_eia3_reference,
ARRAY_SIZE(zuc_eia3_reference));
}
@@ -2886,8 +1825,6 @@ static int check_alg_md5(void)
static void crypto_test_gen_alg_md5(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_MD5,
md5_reference,
ARRAY_SIZE(md5_reference));
}
@@ -2895,8 +1832,6 @@ static void crypto_test_gen_alg_md5(void)
static void crypto_test_check_alg_md5(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_MD5,
md5_reference,
ARRAY_SIZE(md5_reference));
}
@@ -2909,8 +1844,6 @@ static int check_alg_sha1(void)
static void crypto_test_gen_alg_sha1(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA1,
sha1_reference,
ARRAY_SIZE(sha1_reference));
}
@@ -2918,8 +1851,6 @@ static void crypto_test_gen_alg_sha1(void)
static void crypto_test_check_alg_sha1(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA1,
sha1_reference,
ARRAY_SIZE(sha1_reference));
}
@@ -2932,8 +1863,6 @@ static int check_alg_sha224(void)
static void crypto_test_gen_alg_sha224(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA224,
sha224_reference,
ARRAY_SIZE(sha224_reference));
}
@@ -2941,8 +1870,6 @@ static void crypto_test_gen_alg_sha224(void)
static void crypto_test_check_alg_sha224(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA224,
sha224_reference,
ARRAY_SIZE(sha224_reference));
}
@@ -2955,8 +1882,6 @@ static int check_alg_sha256(void)
static void crypto_test_gen_alg_sha256(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA256,
sha256_reference,
ARRAY_SIZE(sha256_reference));
}
@@ -2964,8 +1889,6 @@ static void crypto_test_gen_alg_sha256(void)
static void crypto_test_check_alg_sha256(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA256,
sha256_reference,
ARRAY_SIZE(sha256_reference));
}
@@ -2978,8 +1901,6 @@ static int check_alg_sha384(void)
static void crypto_test_gen_alg_sha384(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA384,
sha384_reference,
ARRAY_SIZE(sha384_reference));
}
@@ -2987,8 +1908,6 @@ static void crypto_test_gen_alg_sha384(void)
static void crypto_test_check_alg_sha384(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA384,
sha384_reference,
ARRAY_SIZE(sha384_reference));
}
@@ -3001,8 +1920,6 @@ static int check_alg_sha512(void)
static void crypto_test_gen_alg_sha512(void)
{
check_alg(ODP_CRYPTO_OP_ENCODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA512,
sha512_reference,
ARRAY_SIZE(sha512_reference));
}
@@ -3010,8 +1927,6 @@ static void crypto_test_gen_alg_sha512(void)
static void crypto_test_check_alg_sha512(void)
{
check_alg(ODP_CRYPTO_OP_DECODE,
- ODP_CIPHER_ALG_NULL,
- ODP_AUTH_ALG_SHA512,
sha512_reference,
ARRAY_SIZE(sha512_reference));
}
@@ -3068,7 +1983,7 @@ static int crypto_suite_packet_async_plain_init(void)
out_queue = plain_compl_queue_create();
if (ODP_QUEUE_INVALID == out_queue) {
- fprintf(stderr, "Crypto outq creation failed.\n");
+ ODPH_ERR("Crypto outq creation failed\n");
return -1;
}
suite_context.queue = out_queue;
@@ -3090,7 +2005,7 @@ static int crypto_suite_packet_async_sched_init(void)
out_queue = sched_compl_queue_create();
if (ODP_QUEUE_INVALID == out_queue) {
- fprintf(stderr, "Crypto outq creation failed.\n");
+ ODPH_ERR("Crypto outq creation failed\n");
return -1;
}
suite_context.queue = out_queue;
@@ -3104,9 +2019,9 @@ static int crypto_suite_term(void)
{
if (ODP_QUEUE_INVALID != suite_context.queue) {
if (odp_queue_destroy(suite_context.queue))
- fprintf(stderr, "Crypto outq destroy failed.\n");
+ ODPH_ERR("Crypto outq destroy failed\n");
} else {
- fprintf(stderr, "Crypto outq not found.\n");
+ ODPH_ERR("Crypto outq not found\n");
}
return odp_cunit_print_inactive();
@@ -3277,7 +2192,7 @@ static int crypto_init(odp_instance_t *inst)
odph_helper_options_t helper_options;
if (odph_options(&helper_options)) {
- fprintf(stderr, "error: odph_options() failed.\n");
+ ODPH_ERR("odph_options() failed\n");
return -1;
}
@@ -3285,23 +2200,23 @@ static int crypto_init(odp_instance_t *inst)
init_param.mem_model = helper_options.mem_model;
if (0 != odp_init_global(inst, &init_param, NULL)) {
- fprintf(stderr, "error: odp_init_global() failed.\n");
+ ODPH_ERR("odp_init_global() failed\n");
return -1;
}
if (0 != odp_init_local(*inst, ODP_THREAD_CONTROL)) {
- fprintf(stderr, "error: odp_init_local() failed.\n");
+ ODPH_ERR("odp_init_local() failed\n");
return -1;
}
/* Configure the scheduler. */
if (odp_schedule_config(NULL)) {
- fprintf(stderr, "odp_schedule_config() failed.\n");
+ ODPH_ERR("odp_schedule_config() failed\n");
return -1;
}
if (odp_pool_capability(&pool_capa) < 0) {
- fprintf(stderr, "error: odp_pool_capability() failed.\n");
+ ODPH_ERR("odp_pool_capability() failed\n");
return -1;
}
@@ -3322,20 +2237,20 @@ static int crypto_init(odp_instance_t *inst)
if (pool_capa.pkt.max_seg_len &&
PKT_POOL_LEN > pool_capa.pkt.max_seg_len) {
- fprintf(stderr, "Warning: small packet segment length\n");
+ ODPH_ERR("Warning: small packet segment length\n");
params.pkt.seg_len = pool_capa.pkt.max_seg_len;
}
if (pool_capa.pkt.max_len &&
PKT_POOL_LEN > pool_capa.pkt.max_len) {
- fprintf(stderr, "Pool max packet length too small\n");
+ ODPH_ERR("Pool max packet length too small\n");
return -1;
}
pool = odp_pool_create("packet_pool", &params);
if (ODP_POOL_INVALID == pool) {
- fprintf(stderr, "Packet pool creation failed.\n");
+ ODPH_ERR("Packet pool creation failed\n");
return -1;
}
@@ -3349,18 +2264,18 @@ static int crypto_term(odp_instance_t inst)
pool = odp_pool_lookup("packet_pool");
if (ODP_POOL_INVALID != pool) {
if (odp_pool_destroy(pool))
- fprintf(stderr, "Packet pool destroy failed.\n");
+ ODPH_ERR("Packet pool destroy failed\n");
} else {
- fprintf(stderr, "Packet pool not found.\n");
+ ODPH_ERR("Packet pool not found\n");
}
if (0 != odp_term_local()) {
- fprintf(stderr, "error: odp_term_local() failed.\n");
+ ODPH_ERR("odp_term_local() failed\n");
return -1;
}
if (0 != odp_term_global(inst)) {
- fprintf(stderr, "error: odp_term_global() failed.\n");
+ ODPH_ERR("odp_term_global() failed\n");
return -1;
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-03 01:01:37 +0000