X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_cryptodev.c;h=ffed298fd61da14b8bc4984d76f41cb0628f3196;hb=ed7092069a3fdef2e520199ae7b835ec42948d79;hp=05422daff2ccfb78632da969d8ed24b8e188ccdb;hpb=8ef48d5333d916fe8826f1e3139796c5e889ad2e;p=dpdk.git diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index 05422daff2..ffed298fd6 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -38,6 +38,10 @@ #include "test_cryptodev_zuc_test_vectors.h" #include "test_cryptodev_aead_test_vectors.h" #include "test_cryptodev_hmac_test_vectors.h" +#ifdef RTE_LIBRTE_SECURITY +#include "test_cryptodev_security_pdcp_test_vectors.h" +#include "test_cryptodev_security_pdcp_test_func.h" +#endif #define VDEV_ARGS_SIZE 100 #define MAX_NB_SESSIONS 4 @@ -65,8 +69,11 @@ struct crypto_unittest_params { struct rte_crypto_sym_xform auth_xform; struct rte_crypto_sym_xform aead_xform; - struct rte_cryptodev_sym_session *sess; - + union { + struct rte_cryptodev_sym_session *sess; + struct rte_security_session *sec_session; + }; + enum rte_security_session_action_type type; struct rte_crypto_op *op; struct rte_mbuf *obuf, *ibuf; @@ -473,7 +480,7 @@ testsuite_setup(void) "Failed to configure cryptodev %u with %u qps", dev_id, ts_params->conf.nb_queue_pairs); - ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; + ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; ts_params->qp_conf.mp_session = ts_params->session_mpool; ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool; @@ -566,11 +573,21 @@ ut_teardown(void) struct rte_cryptodev_stats stats; /* free crypto session structure */ - if (ut_params->sess) { - rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], - ut_params->sess); - rte_cryptodev_sym_session_free(ut_params->sess); - ut_params->sess = NULL; + if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) { + if (ut_params->sec_session) { + rte_security_session_destroy(rte_cryptodev_get_sec_ctx + (ts_params->valid_devs[0]), + ut_params->sec_session); + ut_params->sec_session = NULL; + } + } else { + if (ut_params->sess) { + rte_cryptodev_sym_session_clear( + ts_params->valid_devs[0], + ut_params->sess); + rte_cryptodev_sym_session_free(ut_params->sess); + ut_params->sess = NULL; + } } /* free crypto operation structure */ @@ -2330,6 +2347,25 @@ test_3DES_chain_octeontx_all(void) return TEST_SUCCESS; } +static int +test_AES_chain_nitrox_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, ts_params->session_priv_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NITROX_PMD)), + BLKCIPHER_AES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + static int test_3DES_cipheronly_octeontx_all(void) { @@ -2377,6 +2413,7 @@ create_wireless_algo_hash_session(uint8_t dev_id, enum rte_crypto_auth_algorithm algo) { uint8_t hash_key[key_len]; + int status; struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -2399,9 +2436,10 @@ create_wireless_algo_hash_session(uint8_t dev_id, ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, &ut_params->auth_xform, ts_params->session_priv_mpool); + TEST_ASSERT_EQUAL(status, 0, "session init failed"); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; } @@ -2414,7 +2452,7 @@ create_wireless_algo_cipher_session(uint8_t dev_id, uint8_t iv_len) { uint8_t cipher_key[key_len]; - + int status; struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -2437,9 +2475,10 @@ create_wireless_algo_cipher_session(uint8_t dev_id, ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, &ut_params->cipher_xform, ts_params->session_priv_mpool); + TEST_ASSERT_EQUAL(status, 0, "session init failed"); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; } @@ -2517,6 +2556,7 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id, { uint8_t cipher_auth_key[key_len]; + int status; struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -2554,10 +2594,11 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id, ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, &ut_params->cipher_xform, ts_params->session_priv_mpool); + TEST_ASSERT_EQUAL(status, 0, "session init failed"); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; } @@ -2572,6 +2613,7 @@ create_wireless_cipher_auth_session(uint8_t dev_id, { const uint8_t key_len = tdata->key.len; uint8_t cipher_auth_key[key_len]; + int status; struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -2614,10 +2656,11 @@ create_wireless_cipher_auth_session(uint8_t dev_id, ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, &ut_params->cipher_xform, ts_params->session_priv_mpool); + TEST_ASSERT_EQUAL(status, 0, "session init failed"); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; } @@ -2643,7 +2686,7 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id, uint8_t cipher_iv_len) { uint8_t auth_cipher_key[key_len]; - + int status; struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; @@ -2677,10 +2720,10 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id, ut_params->sess = rte_cryptodev_sym_session_create( ts_params->session_mpool); - rte_cryptodev_sym_session_init(dev_id, ut_params->sess, + status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, &ut_params->auth_xform, ts_params->session_priv_mpool); - + TEST_ASSERT_EQUAL(status, 0, "session init failed"); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; @@ -2909,8 +2952,6 @@ create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len, (op_mode == IN_PLACE ? ut_params->ibuf : ut_params->obuf), data_pad_len); - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append auth tag"); memset(sym_op->auth.digest.data, 0, auth_tag_len); } else { uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3); @@ -2924,8 +2965,6 @@ create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len, uint8_t *, remaining_off); sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf, remaining_off); - TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, - "no room to append auth tag"); memset(sym_op->auth.digest.data, 0, remaining_off); while (sgl_buf->next != NULL) { memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *), @@ -5002,7 +5041,7 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, } memset(buffer, 0, sizeof(buffer)); - /* Create SNOW 3G operation */ + /* Create KASUMI operation */ retval = create_wireless_algo_auth_cipher_operation( tdata->digest.len, tdata->cipher_iv.data, tdata->cipher_iv.len, @@ -5432,6 +5471,15 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, unsigned int ciphertext_len; struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_capability_idx cap_idx; + + /* Check if device supports ZUC EIA3 */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -5444,7 +5492,7 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, } } - /* Create KASUMI session */ + /* Create ZUC session */ retval = create_wireless_algo_auth_cipher_session( ts_params->valid_devs[0], (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT @@ -5473,8 +5521,6 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, ciphertext_len = ceil_byte_length(tdata->ciphertext.len); plaintext_len = ceil_byte_length(tdata->plaintext.len); - /* Append data which is padded to a multiple of */ - /* the algorithms block size */ ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); @@ -5600,6 +5646,15 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, uint8_t digest_buffer[10000]; struct rte_cryptodev_info dev_info; + struct rte_cryptodev_sym_capability_idx cap_idx; + + /* Check if device supports ZUC EIA3 */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + return -ENOTSUP; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -7002,180 +7057,849 @@ test_authenticated_encryption(const struct aead_test_data *tdata) } +#ifdef RTE_LIBRTE_SECURITY +/* Basic algorithm run function for async inplace mode. + * Creates a session from input parameters and runs one operation + * on input_vec. Checks the output of the crypto operation against + * output_vec. + */ static int -test_AES_GCM_authenticated_encryption_test_case_1(void) -{ - return test_authenticated_encryption(&gcm_test_case_1); -} - -static int -test_AES_GCM_authenticated_encryption_test_case_2(void) +test_pdcp_proto(int i, int oop, + enum rte_crypto_cipher_operation opc, + enum rte_crypto_auth_operation opa, + uint8_t *input_vec, + unsigned int input_vec_len, + uint8_t *output_vec, + unsigned int output_vec_len) { - return test_authenticated_encryption(&gcm_test_case_2); -} + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + uint8_t *plaintext; + int ret = TEST_SUCCESS; -static int -test_AES_GCM_authenticated_encryption_test_case_3(void) -{ - return test_authenticated_encryption(&gcm_test_case_3); -} + /* Generate test mbuf data */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); -static int -test_AES_GCM_authenticated_encryption_test_case_4(void) -{ - return test_authenticated_encryption(&gcm_test_case_4); -} + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); -static int -test_AES_GCM_authenticated_encryption_test_case_5(void) -{ - return test_authenticated_encryption(&gcm_test_case_5); -} + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + input_vec_len); + memcpy(plaintext, input_vec, input_vec_len); -static int -test_AES_GCM_authenticated_encryption_test_case_6(void) -{ - return test_authenticated_encryption(&gcm_test_case_6); -} + /* Out of place support */ + if (oop) { + /* + * For out-op-place we need to alloc another mbuf + */ + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + rte_pktmbuf_append(ut_params->obuf, output_vec_len); + } -static int -test_AES_GCM_authenticated_encryption_test_case_7(void) -{ - return test_authenticated_encryption(&gcm_test_case_7); -} + /* Set crypto type as IPSEC */ + ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; -static int -test_AES_GCM_auth_encryption_test_case_192_1(void) -{ - return test_authenticated_encryption(&gcm_test_case_192_1); -} + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg; + ut_params->cipher_xform.cipher.op = opc; + ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i]; + ut_params->cipher_xform.cipher.key.length = + pdcp_test_params[i].cipher_key_len; + ut_params->cipher_xform.cipher.iv.length = 0; + + /* Setup HMAC Parameters if ICV header is required */ + if (pdcp_test_params[i].auth_alg != 0) { + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg; + ut_params->auth_xform.auth.op = opa; + ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i]; + ut_params->auth_xform.auth.key.length = + pdcp_test_params[i].auth_key_len; + + ut_params->cipher_xform.next = &ut_params->auth_xform; + } else { + ut_params->cipher_xform.next = NULL; + } -static int -test_AES_GCM_auth_encryption_test_case_192_2(void) -{ - return test_authenticated_encryption(&gcm_test_case_192_2); -} + struct rte_security_session_conf sess_conf = { + .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .protocol = RTE_SECURITY_PROTOCOL_PDCP, + {.pdcp = { + .bearer = pdcp_test_bearer[i], + .domain = pdcp_test_params[i].domain, + .pkt_dir = pdcp_test_packet_direction[i], + .sn_size = pdcp_test_data_sn_size[i], + .hfn = pdcp_test_hfn[i], + .hfn_threshold = pdcp_test_hfn_threshold[i], + } }, + .crypto_xform = &ut_params->cipher_xform + }; -static int -test_AES_GCM_auth_encryption_test_case_192_3(void) -{ - return test_authenticated_encryption(&gcm_test_case_192_3); -} + struct rte_security_ctx *ctx = (struct rte_security_ctx *) + rte_cryptodev_get_sec_ctx( + ts_params->valid_devs[0]); -static int -test_AES_GCM_auth_encryption_test_case_192_4(void) -{ - return test_authenticated_encryption(&gcm_test_case_192_4); -} + /* Create security session */ + ut_params->sec_session = rte_security_session_create(ctx, + &sess_conf, ts_params->session_mpool); -static int -test_AES_GCM_auth_encryption_test_case_192_5(void) -{ - return test_authenticated_encryption(&gcm_test_case_192_5); -} + if (!ut_params->sec_session) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, "Failed to allocate session"); + ret = TEST_FAILED; + goto on_err; + } -static int -test_AES_GCM_auth_encryption_test_case_192_6(void) -{ - return test_authenticated_encryption(&gcm_test_case_192_6); -} + /* Generate crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (!ut_params->op) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, + "Failed to allocate symmetric crypto operation struct"); + ret = TEST_FAILED; + goto on_err; + } -static int -test_AES_GCM_auth_encryption_test_case_192_7(void) -{ - return test_authenticated_encryption(&gcm_test_case_192_7); -} + rte_security_attach_session(ut_params->op, ut_params->sec_session); -static int -test_AES_GCM_auth_encryption_test_case_256_1(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_1); -} + /* set crypto operation source mbuf */ + ut_params->op->sym->m_src = ut_params->ibuf; + if (oop) + ut_params->op->sym->m_dst = ut_params->obuf; -static int -test_AES_GCM_auth_encryption_test_case_256_2(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_2); -} + /* Process crypto operation */ + if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) + == NULL) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, + "failed to process sym crypto op"); + ret = TEST_FAILED; + goto on_err; + } -static int -test_AES_GCM_auth_encryption_test_case_256_3(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_3); -} + if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, "crypto op processing failed"); + ret = TEST_FAILED; + goto on_err; + } -static int -test_AES_GCM_auth_encryption_test_case_256_4(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_4); -} + /* Validate obuf */ + uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, + uint8_t *); + if (oop) { + ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + } -static int -test_AES_GCM_auth_encryption_test_case_256_5(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_5); -} + if (memcmp(ciphertext, output_vec, output_vec_len)) { + printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); + rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len); + rte_hexdump(stdout, "reference", output_vec, output_vec_len); + ret = TEST_FAILED; + goto on_err; + } -static int -test_AES_GCM_auth_encryption_test_case_256_6(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_6); -} +on_err: + rte_crypto_op_free(ut_params->op); + ut_params->op = NULL; -static int -test_AES_GCM_auth_encryption_test_case_256_7(void) -{ - return test_authenticated_encryption(&gcm_test_case_256_7); -} + if (ut_params->sec_session) + rte_security_session_destroy(ctx, ut_params->sec_session); + ut_params->sec_session = NULL; -static int -test_AES_GCM_auth_encryption_test_case_aad_1(void) -{ - return test_authenticated_encryption(&gcm_test_case_aad_1); -} + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = NULL; + if (oop) { + rte_pktmbuf_free(ut_params->obuf); + ut_params->obuf = NULL; + } -static int -test_AES_GCM_auth_encryption_test_case_aad_2(void) -{ - return test_authenticated_encryption(&gcm_test_case_aad_2); + return ret; } static int -test_authenticated_decryption(const struct aead_test_data *tdata) +test_pdcp_proto_SGL(int i, int oop, + enum rte_crypto_cipher_operation opc, + enum rte_crypto_auth_operation opa, + uint8_t *input_vec, + unsigned int input_vec_len, + uint8_t *output_vec, + unsigned int output_vec_len, + uint32_t fragsz, + uint32_t fragsz_oop) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; - - int retval; uint8_t *plaintext; - uint32_t i; - - /* Create AEAD session */ - retval = create_aead_session(ts_params->valid_devs[0], - tdata->algo, - RTE_CRYPTO_AEAD_OP_DECRYPT, - tdata->key.data, tdata->key.len, - tdata->aad.len, tdata->auth_tag.len, - tdata->iv.len); - if (retval < 0) - return retval; + struct rte_mbuf *buf, *buf_oop = NULL; + int ret = TEST_SUCCESS; + int to_trn = 0; + int to_trn_tbl[16]; + int segs = 1; + unsigned int trn_data = 0; - /* alloc mbuf and set payload */ - if (tdata->aad.len > MBUF_SIZE) { - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); - /* Populate full size of add data */ - for (i = 32; i < MAX_AAD_LENGTH; i += 32) - memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); - } else - ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + if (fragsz > input_vec_len) + fragsz = input_vec_len; - memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, - rte_pktmbuf_tailroom(ut_params->ibuf)); + uint16_t plaintext_len = fragsz; + uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz; - /* Create AEAD operation */ - retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); - if (retval < 0) - return retval; + if (fragsz_oop > output_vec_len) + frag_size_oop = output_vec_len; + + int ecx = 0; + if (input_vec_len % fragsz != 0) { + if (input_vec_len / fragsz + 1 > 16) + return 1; + } else if (input_vec_len / fragsz > 16) + return 1; + + /* Out of place support */ + if (oop) { + /* + * For out-op-place we need to alloc another mbuf + */ + ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + rte_pktmbuf_append(ut_params->obuf, frag_size_oop); + buf_oop = ut_params->obuf; + } + + /* Generate test mbuf data */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + /* clear mbuf payload */ + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_len); + memcpy(plaintext, input_vec, plaintext_len); + trn_data += plaintext_len; + + buf = ut_params->ibuf; + + /* + * Loop until no more fragments + */ + + while (trn_data < input_vec_len) { + ++segs; + to_trn = (input_vec_len - trn_data < fragsz) ? + (input_vec_len - trn_data) : fragsz; + + to_trn_tbl[ecx++] = to_trn; + + buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf = buf->next; + + memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, + rte_pktmbuf_tailroom(buf)); + + /* OOP */ + if (oop && !fragsz_oop) { + buf_oop->next = + rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf_oop = buf_oop->next; + memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), + 0, rte_pktmbuf_tailroom(buf_oop)); + rte_pktmbuf_append(buf_oop, to_trn); + } + + plaintext = (uint8_t *)rte_pktmbuf_append(buf, + to_trn); + + memcpy(plaintext, input_vec + trn_data, to_trn); + trn_data += to_trn; + } + + ut_params->ibuf->nb_segs = segs; + + segs = 1; + if (fragsz_oop && oop) { + to_trn = 0; + ecx = 0; + + trn_data = frag_size_oop; + while (trn_data < output_vec_len) { + ++segs; + to_trn = + (output_vec_len - trn_data < + frag_size_oop) ? + (output_vec_len - trn_data) : + frag_size_oop; + + to_trn_tbl[ecx++] = to_trn; + + buf_oop->next = + rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf_oop = buf_oop->next; + memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), + 0, rte_pktmbuf_tailroom(buf_oop)); + rte_pktmbuf_append(buf_oop, to_trn); + + trn_data += to_trn; + } + ut_params->obuf->nb_segs = segs; + } + + ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + + /* Setup Cipher Parameters */ + ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg; + ut_params->cipher_xform.cipher.op = opc; + ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i]; + ut_params->cipher_xform.cipher.key.length = + pdcp_test_params[i].cipher_key_len; + ut_params->cipher_xform.cipher.iv.length = 0; + + /* Setup HMAC Parameters if ICV header is required */ + if (pdcp_test_params[i].auth_alg != 0) { + ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + ut_params->auth_xform.next = NULL; + ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg; + ut_params->auth_xform.auth.op = opa; + ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i]; + ut_params->auth_xform.auth.key.length = + pdcp_test_params[i].auth_key_len; + + ut_params->cipher_xform.next = &ut_params->auth_xform; + } else { + ut_params->cipher_xform.next = NULL; + } + + struct rte_security_session_conf sess_conf = { + .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .protocol = RTE_SECURITY_PROTOCOL_PDCP, + {.pdcp = { + .bearer = pdcp_test_bearer[i], + .domain = pdcp_test_params[i].domain, + .pkt_dir = pdcp_test_packet_direction[i], + .sn_size = pdcp_test_data_sn_size[i], + .hfn = pdcp_test_hfn[i], + .hfn_threshold = pdcp_test_hfn_threshold[i], + } }, + .crypto_xform = &ut_params->cipher_xform + }; + + struct rte_security_ctx *ctx = (struct rte_security_ctx *) + rte_cryptodev_get_sec_ctx( + ts_params->valid_devs[0]); + + /* Create security session */ + ut_params->sec_session = rte_security_session_create(ctx, + &sess_conf, ts_params->session_mpool); + + if (!ut_params->sec_session) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, "Failed to allocate session"); + ret = TEST_FAILED; + goto on_err; + } + + /* Generate crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (!ut_params->op) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, + "Failed to allocate symmetric crypto operation struct"); + ret = TEST_FAILED; + goto on_err; + } + + rte_security_attach_session(ut_params->op, ut_params->sec_session); + + /* set crypto operation source mbuf */ + ut_params->op->sym->m_src = ut_params->ibuf; + if (oop) + ut_params->op->sym->m_dst = ut_params->obuf; + + /* Process crypto operation */ + if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) + == NULL) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, + "failed to process sym crypto op"); + ret = TEST_FAILED; + goto on_err; + } + + if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { + printf("TestCase %s()-%d line %d failed %s: ", + __func__, i, __LINE__, "crypto op processing failed"); + ret = TEST_FAILED; + goto on_err; + } + + /* Validate obuf */ + uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, + uint8_t *); + if (oop) { + ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, + uint8_t *); + } + if (fragsz_oop) + fragsz = frag_size_oop; + if (memcmp(ciphertext, output_vec, fragsz)) { + printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); + rte_hexdump(stdout, "encrypted", ciphertext, fragsz); + rte_hexdump(stdout, "reference", output_vec, fragsz); + ret = TEST_FAILED; + goto on_err; + } + + buf = ut_params->op->sym->m_src->next; + if (oop) + buf = ut_params->op->sym->m_dst->next; + + unsigned int off = fragsz; + + ecx = 0; + while (buf) { + ciphertext = rte_pktmbuf_mtod(buf, + uint8_t *); + if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) { + printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); + rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]); + rte_hexdump(stdout, "reference", output_vec + off, + to_trn_tbl[ecx]); + ret = TEST_FAILED; + goto on_err; + } + off += to_trn_tbl[ecx++]; + buf = buf->next; + } +on_err: + rte_crypto_op_free(ut_params->op); + ut_params->op = NULL; + + if (ut_params->sec_session) + rte_security_session_destroy(ctx, ut_params->sec_session); + ut_params->sec_session = NULL; + + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = NULL; + if (oop) { + rte_pktmbuf_free(ut_params->obuf); + ut_params->obuf = NULL; + } + + return ret; +} + +int +test_pdcp_proto_cplane_encap(int i) +{ + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]+4); +} + +int +test_pdcp_proto_uplane_encap(int i) +{ + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]); + +} + +int +test_pdcp_proto_uplane_encap_with_int(int i) +{ + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i] + 4); +} + +int +test_pdcp_proto_cplane_decap(int i) +{ + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_AUTH_OP_VERIFY, + pdcp_test_data_out[i], + pdcp_test_data_in_len[i] + 4, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i]); +} + +int +test_pdcp_proto_uplane_decap(int i) +{ + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_AUTH_OP_VERIFY, + pdcp_test_data_out[i], + pdcp_test_data_in_len[i], + pdcp_test_data_in[i], + pdcp_test_data_in_len[i]); +} + +int +test_pdcp_proto_uplane_decap_with_int(int i) +{ + return test_pdcp_proto(i, 0, + RTE_CRYPTO_CIPHER_OP_DECRYPT, + RTE_CRYPTO_AUTH_OP_VERIFY, + pdcp_test_data_out[i], + pdcp_test_data_in_len[i] + 4, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i]); +} + +static int +test_PDCP_PROTO_SGL_in_place_32B(void) +{ + /* i can be used for running any PDCP case + * In this case it is uplane 12-bit AES-SNOW DL encap + */ + int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK; + return test_pdcp_proto_SGL(i, IN_PLACE, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]+4, + 32, 0); +} +static int +test_PDCP_PROTO_SGL_oop_32B_128B(void) +{ + /* i can be used for running any PDCP case + * In this case it is uplane 18-bit NULL-NULL DL encap + */ + int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK; + return test_pdcp_proto_SGL(i, OUT_OF_PLACE, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]+4, + 32, 128); +} +static int +test_PDCP_PROTO_SGL_oop_32B_40B(void) +{ + /* i can be used for running any PDCP case + * In this case it is uplane 18-bit AES DL encap + */ + int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET + + DOWNLINK; + return test_pdcp_proto_SGL(i, OUT_OF_PLACE, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i], + 32, 40); +} +static int +test_PDCP_PROTO_SGL_oop_128B_32B(void) +{ + /* i can be used for running any PDCP case + * In this case it is cplane 12-bit AES-ZUC DL encap + */ + int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK; + return test_pdcp_proto_SGL(i, OUT_OF_PLACE, + RTE_CRYPTO_CIPHER_OP_ENCRYPT, + RTE_CRYPTO_AUTH_OP_GENERATE, + pdcp_test_data_in[i], + pdcp_test_data_in_len[i], + pdcp_test_data_out[i], + pdcp_test_data_in_len[i]+4, + 128, 32); +} +#endif + +static int +test_AES_GCM_authenticated_encryption_test_case_1(void) +{ + return test_authenticated_encryption(&gcm_test_case_1); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_2(void) +{ + return test_authenticated_encryption(&gcm_test_case_2); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_3(void) +{ + return test_authenticated_encryption(&gcm_test_case_3); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_4(void) +{ + return test_authenticated_encryption(&gcm_test_case_4); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_5(void) +{ + return test_authenticated_encryption(&gcm_test_case_5); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_6(void) +{ + return test_authenticated_encryption(&gcm_test_case_6); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_7(void) +{ + return test_authenticated_encryption(&gcm_test_case_7); +} + +static int +test_AES_GCM_authenticated_encryption_test_case_8(void) +{ + return test_authenticated_encryption(&gcm_test_case_8); +} + +static int +test_AES_GCM_auth_encryption_test_case_192_1(void) +{ + return test_authenticated_encryption(&gcm_test_case_192_1); +} + +static int +test_AES_GCM_auth_encryption_test_case_192_2(void) +{ + return test_authenticated_encryption(&gcm_test_case_192_2); +} + +static int +test_AES_GCM_auth_encryption_test_case_192_3(void) +{ + return test_authenticated_encryption(&gcm_test_case_192_3); +} + +static int +test_AES_GCM_auth_encryption_test_case_192_4(void) +{ + return test_authenticated_encryption(&gcm_test_case_192_4); +} + +static int +test_AES_GCM_auth_encryption_test_case_192_5(void) +{ + return test_authenticated_encryption(&gcm_test_case_192_5); +} + +static int +test_AES_GCM_auth_encryption_test_case_192_6(void) +{ + return test_authenticated_encryption(&gcm_test_case_192_6); +} + +static int +test_AES_GCM_auth_encryption_test_case_192_7(void) +{ + return test_authenticated_encryption(&gcm_test_case_192_7); +} + +static int +test_AES_GCM_auth_encryption_test_case_256_1(void) +{ + return test_authenticated_encryption(&gcm_test_case_256_1); +} + +static int +test_AES_GCM_auth_encryption_test_case_256_2(void) +{ + return test_authenticated_encryption(&gcm_test_case_256_2); +} + +static int +test_AES_GCM_auth_encryption_test_case_256_3(void) +{ + return test_authenticated_encryption(&gcm_test_case_256_3); +} + +static int +test_AES_GCM_auth_encryption_test_case_256_4(void) +{ + return test_authenticated_encryption(&gcm_test_case_256_4); +} + +static int +test_AES_GCM_auth_encryption_test_case_256_5(void) +{ + return test_authenticated_encryption(&gcm_test_case_256_5); +} + +static int +test_AES_GCM_auth_encryption_test_case_256_6(void) +{ + return test_authenticated_encryption(&gcm_test_case_256_6); +} + +static int +test_AES_GCM_auth_encryption_test_case_256_7(void) +{ + return test_authenticated_encryption(&gcm_test_case_256_7); +} + +static int +test_AES_GCM_auth_encryption_test_case_aad_1(void) +{ + return test_authenticated_encryption(&gcm_test_case_aad_1); +} + +static int +test_AES_GCM_auth_encryption_test_case_aad_2(void) +{ + return test_authenticated_encryption(&gcm_test_case_aad_2); +} + +static int +test_AES_GCM_auth_encryption_fail_iv_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.iv.data[0] += 1; + res = test_authenticated_encryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_in_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.plaintext.data[0] += 1; + res = test_authenticated_encryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_out_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.ciphertext.data[0] += 1; + res = test_authenticated_encryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.aad.len += 1; + res = test_authenticated_encryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_aad_corrupt(void) +{ + struct aead_test_data tdata; + uint8_t aad[gcm_test_case_7.aad.len]; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len); + aad[0] += 1; + tdata.aad.data = aad; + res = test_authenticated_encryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_encryption_fail_tag_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.auth_tag.data[0] += 1; + res = test_authenticated_encryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); + return TEST_SUCCESS; +} + +static int +test_authenticated_decryption(const struct aead_test_data *tdata) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + + int retval; + uint8_t *plaintext; + uint32_t i; + + /* Create AEAD session */ + retval = create_aead_session(ts_params->valid_devs[0], + tdata->algo, + RTE_CRYPTO_AEAD_OP_DECRYPT, + tdata->key.data, tdata->key.len, + tdata->aad.len, tdata->auth_tag.len, + tdata->iv.len); + if (retval < 0) + return retval; + + /* alloc mbuf and set payload */ + if (tdata->aad.len > MBUF_SIZE) { + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); + /* Populate full size of add data */ + for (i = 32; i < MAX_AAD_LENGTH; i += 32) + memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); + } else + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + /* Create AEAD operation */ + retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); + if (retval < 0) + return retval; rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); @@ -7208,6 +7932,7 @@ test_authenticated_decryption(const struct aead_test_data *tdata) TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "Authentication failed"); + return 0; } @@ -7253,6 +7978,12 @@ test_AES_GCM_authenticated_decryption_test_case_7(void) return test_authenticated_decryption(&gcm_test_case_7); } +static int +test_AES_GCM_authenticated_decryption_test_case_8(void) +{ + return test_authenticated_decryption(&gcm_test_case_8); +} + static int test_AES_GCM_auth_decryption_test_case_192_1(void) { @@ -7349,6 +8080,88 @@ test_AES_GCM_auth_decryption_test_case_aad_2(void) return test_authenticated_decryption(&gcm_test_case_aad_2); } +static int +test_AES_GCM_auth_decryption_fail_iv_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.iv.data[0] += 1; + res = test_authenticated_decryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_decryption_fail_in_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.plaintext.data[0] += 1; + res = test_authenticated_decryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_decryption_fail_out_data_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.ciphertext.data[0] += 1; + res = test_authenticated_decryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.aad.len += 1; + res = test_authenticated_decryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_decryption_fail_aad_corrupt(void) +{ + struct aead_test_data tdata; + uint8_t aad[gcm_test_case_7.aad.len]; + int res; + + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len); + aad[0] += 1; + tdata.aad.data = aad; + res = test_authenticated_decryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); + return TEST_SUCCESS; +} + +static int +test_AES_GCM_auth_decryption_fail_tag_corrupt(void) +{ + struct aead_test_data tdata; + int res; + + memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); + tdata.auth_tag.data[0] += 1; + res = test_authenticated_decryption(&tdata); + TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed"); + return TEST_SUCCESS; +} + static int test_authenticated_encryption_oop(const struct aead_test_data *tdata) { @@ -9391,8 +10204,8 @@ test_authentication_verify_fail_when_data_corruption( ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_AUTH_FAILED, + TEST_ASSERT_NOT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, "authentication not failed"); ut_params->obuf = ut_params->op->sym->m_src; @@ -9452,8 +10265,8 @@ test_authentication_verify_GMAC_fail_when_corruption( ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_AUTH_FAILED, + TEST_ASSERT_NOT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, "authentication not failed"); ut_params->obuf = ut_params->op->sym->m_src; @@ -9513,8 +10326,8 @@ test_authenticated_decryption_fail_when_corruption( ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); - TEST_ASSERT_EQUAL(ut_params->op->status, - RTE_CRYPTO_OP_STATUS_AUTH_FAILED, + TEST_ASSERT_NOT_EQUAL(ut_params->op->status, + RTE_CRYPTO_OP_STATUS_SUCCESS, "authentication not failed"); ut_params->obuf = ut_params->op->sym->m_src; @@ -10296,6 +11109,8 @@ static struct unit_test_suite cryptodev_qat_testsuite = { test_AES_GCM_authenticated_encryption_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_encryption_test_case_7), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_8), /** AES GCM Authenticated Decryption */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -10312,6 +11127,8 @@ static struct unit_test_suite cryptodev_qat_testsuite = { test_AES_GCM_authenticated_decryption_test_case_6), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_decryption_test_case_7), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_8), /** AES GCM Authenticated Encryption 192 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -10361,6 +11178,22 @@ static struct unit_test_suite cryptodev_qat_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_auth_encryption_test_case_256_7), + /** AES GCM Authenticated Decryption 256 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_7), + /** AES GMAC Authentication */ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_test_case_1), @@ -10583,6 +11416,30 @@ static struct unit_test_suite cryptodev_qat_testsuite = { authentication_verify_HMAC_SHA1_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, authentication_verify_HMAC_SHA1_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_fail_iv_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_fail_in_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_fail_out_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_fail_aad_len_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_fail_aad_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_iv_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_in_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_out_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_aad_len_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_aad_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_fail_tag_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, authentication_verify_AES128_GMAC_fail_data_corrupt), TEST_CASE_ST(ut_setup, ut_teardown, @@ -11414,6 +12271,28 @@ static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_dpaa_sec_all), +#ifdef RTE_LIBRTE_SECURITY + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_cplane_encap_all), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_cplane_decap_all), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_uplane_encap_all), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_uplane_decap_all), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_SGL_in_place_32B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_SGL_oop_32B_128B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_SGL_oop_32B_40B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_SGL_oop_128B_32B), +#endif /** AES GCM Authenticated Encryption */ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_encryption_test_case_1), @@ -11494,6 +12373,16 @@ static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B), + /** Negative tests */ + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), + TEST_CASES_END() /**< NULL terminate unit test array */ } }; @@ -11519,6 +12408,28 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_dpaa2_sec_all), +#ifdef RTE_LIBRTE_SECURITY + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_cplane_encap_all), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_cplane_decap_all), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_uplane_encap_all), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_uplane_decap_all), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_SGL_in_place_32B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_SGL_oop_32B_128B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_SGL_oop_32B_40B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_PDCP_PROTO_SGL_oop_128B_32B), +#endif /** AES GCM Authenticated Encryption */ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_encryption_test_case_1), @@ -11631,6 +12542,80 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B), + /** SNOW 3G encrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_5), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_1_oop_sgl), + + /** SNOW 3G decrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_5), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_3), + + /** ZUC encrypt only (EEA3) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_5), + + /** ZUC authenticate (EIA3) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_7), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_8), + + /** Negative tests */ + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), + TEST_CASES_END() /**< NULL terminate unit test array */ } }; @@ -11950,6 +12935,22 @@ static struct unit_test_suite cryptodev_octeontx_testsuite = { } }; +static struct unit_test_suite cryptodev_nitrox_testsuite = { + .suite_name = "Crypto NITROX Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_setup, ut_teardown, + test_device_configure_invalid_dev_id), + TEST_CASE_ST(ut_setup, ut_teardown, + test_device_configure_invalid_queue_pair_ids), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_chain_nitrox_all), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + static int test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) { @@ -12233,6 +13234,22 @@ test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/) return unit_test_suite_runner(&cryptodev_caam_jr_testsuite); } +static int +test_cryptodev_nitrox(void) +{ + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_NITROX_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "NITROX PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_NITROX is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } + + return unit_test_suite_runner(&cryptodev_nitrox_testsuite); +} + REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl); @@ -12249,3 +13266,4 @@ REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp); REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio); REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx); REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr); +REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);