+ return 0;
+}
+
+static int
+test_authenticated_encryption(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 *ciphertext, *auth_tag;
+ uint16_t plaintext_pad_len;
+ uint32_t i;
+
+ /* Create AEAD session */
+ retval = create_aead_session(ts_params->valid_devs[0],
+ tdata->algo,
+ RTE_CRYPTO_AEAD_OP_ENCRYPT,
+ tdata->key.data, tdata->key.len,
+ tdata->aad.len, tdata->auth_tag.len,
+ tdata->iv.len);
+ if (retval < 0)
+ return retval;
+
+ 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);
+
+ /* clear mbuf payload */
+ 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_ENCRYPT, tdata);
+ if (retval < 0)
+ return retval;
+
+ rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
+
+ ut_params->op->sym->m_src = ut_params->ibuf;
+
+ /* Process crypto operation */
+ TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
+ ut_params->op), "failed to process sym crypto op");
+
+ TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
+ "crypto op processing failed");
+
+ plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+
+ if (ut_params->op->sym->m_dst) {
+ ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
+ uint8_t *);
+ auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
+ uint8_t *, plaintext_pad_len);
+ } else {
+ ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
+ uint8_t *,
+ ut_params->op->sym->cipher.data.offset);
+ auth_tag = ciphertext + plaintext_pad_len;
+ }
+
+ debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
+ debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
+
+ /* Validate obuf */
+ TEST_ASSERT_BUFFERS_ARE_EQUAL(
+ ciphertext,
+ tdata->ciphertext.data,
+ tdata->ciphertext.len,
+ "Ciphertext data not as expected");
+
+ TEST_ASSERT_BUFFERS_ARE_EQUAL(
+ auth_tag,
+ tdata->auth_tag.data,
+ tdata->auth_tag.len,
+ "Generated auth tag not as expected");
+
+ return 0;
+
+}
+
+#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_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)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
+ uint8_t *plaintext;
+ int ret = TEST_SUCCESS;
+
+ /* 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,
+ input_vec_len);
+ memcpy(plaintext, input_vec, input_vec_len);
+
+ /* 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);
+ }
+
+ /* Set crypto type as IPSEC */
+ 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 (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;
+ }
+
+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;
+}
+
+static int
+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;
+ uint8_t *plaintext;
+ 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;
+
+ if (fragsz > input_vec_len)
+ fragsz = input_vec_len;
+
+ uint16_t plaintext_len = fragsz;
+ uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
+
+ 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;