test: fix autotest list
[dpdk.git] / test / test / test_cryptodev_asym.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 Cavium Networks
3  */
4
5 #include <rte_bus_vdev.h>
6 #include <rte_common.h>
7 #include <rte_hexdump.h>
8 #include <rte_mbuf.h>
9 #include <rte_malloc.h>
10 #include <rte_memcpy.h>
11 #include <rte_pause.h>
12
13 #include <rte_cryptodev.h>
14 #include <rte_cryptodev_pmd.h>
15 #include <rte_crypto.h>
16
17 #include "test_cryptodev.h"
18 #include "test_cryptodev_dh_test_vectors.h"
19 #include "test_cryptodev_dsa_test_vectors.h"
20 #include "test_cryptodev_mod_test_vectors.h"
21 #include "test_cryptodev_rsa_test_vectors.h"
22 #include "test_cryptodev_asym_util.h"
23 #include "test.h"
24
25 #define TEST_NUM_BUFS 10
26 #define TEST_NUM_SESSIONS 4
27
28 static int gbl_driver_id;
29 struct crypto_testsuite_params {
30         struct rte_mempool *op_mpool;
31         struct rte_mempool *session_mpool;
32         struct rte_cryptodev_config conf;
33         struct rte_cryptodev_qp_conf qp_conf;
34         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
35         uint8_t valid_dev_count;
36 };
37
38 struct crypto_unittest_params {
39         struct rte_cryptodev_asym_session *sess;
40         struct rte_crypto_op *op;
41 };
42
43 static struct crypto_testsuite_params testsuite_params = { NULL };
44
45 static int
46 test_rsa_sign_verify(void)
47 {
48         struct crypto_testsuite_params *ts_params = &testsuite_params;
49         struct rte_mempool *op_mpool = ts_params->op_mpool;
50         struct rte_mempool *sess_mpool = ts_params->session_mpool;
51         uint8_t dev_id = ts_params->valid_devs[0];
52         struct rte_crypto_asym_op *asym_op = NULL;
53         struct rte_crypto_op *op = NULL, *result_op = NULL;
54         struct rte_cryptodev_asym_session *sess = NULL;
55         int status = TEST_SUCCESS;
56         uint8_t output_buf[TEST_DATA_SIZE] = {0};
57         uint8_t input_buf[TEST_DATA_SIZE] = {0};
58
59         sess = rte_cryptodev_asym_session_create(sess_mpool);
60
61         if (!sess) {
62                 RTE_LOG(ERR, USER1, "line %u "
63                                 "FAILED: %s", __LINE__,
64                                 "Session creation failed");
65                 status = TEST_FAILED;
66                 goto error_exit;
67         }
68
69         if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform,
70                                 sess_mpool) < 0) {
71                 RTE_LOG(ERR, USER1,
72                                 "line %u FAILED: %s",
73                                 __LINE__, "unabled to config sym session");
74                 status = TEST_FAILED;
75                 goto error_exit;
76         }
77
78         /* set up crypto op data structure */
79         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
80         if (!op) {
81                 RTE_LOG(ERR, USER1,
82                                 "line %u FAILED: %s",
83                                 __LINE__,
84                                 "Failed to allocate asymmetric crypto "
85                                 "operation struct");
86                 status = TEST_FAILED;
87                 goto error_exit;
88         }
89
90         asym_op = op->asym;
91         /* Compute sign on the test vector */
92         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN;
93
94         memcpy(input_buf, &rsaplaintext.data,
95                         rsaplaintext.len);
96         asym_op->rsa.message.data = input_buf;
97         asym_op->rsa.message.length = rsaplaintext.len;
98         asym_op->rsa.sign.data = output_buf;
99         asym_op->rsa.pad = RTE_CRYPTO_RSA_PKCS1_V1_5_BT1;
100
101         debug_hexdump(stdout, "message", asym_op->rsa.message.data,
102                         asym_op->rsa.message.length);
103
104         /* attach asymmetric crypto session to crypto operations */
105         rte_crypto_op_attach_asym_session(op, sess);
106
107         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
108
109         /* Process crypto operation */
110         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
111                 RTE_LOG(ERR, USER1,
112                                 "line %u FAILED: %s",
113                                 __LINE__, "Error sending packet for operation");
114                 status = TEST_FAILED;
115                 goto error_exit;
116         }
117
118         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
119                 rte_pause();
120
121         if (result_op == NULL) {
122                 RTE_LOG(ERR, USER1,
123                                 "line %u FAILED: %s",
124                                 __LINE__, "Failed to process asym crypto op");
125                 status = TEST_FAILED;
126                 goto error_exit;
127         }
128         debug_hexdump(stdout, "signed message", asym_op->rsa.sign.data,
129                         asym_op->rsa.sign.length);
130         asym_op = result_op->asym;
131
132         /* Verify sign */
133         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY;
134         asym_op->rsa.pad = RTE_CRYPTO_RSA_PKCS1_V1_5_BT2;
135
136         /* Process crypto operation */
137         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
138                 RTE_LOG(ERR, USER1,
139                                 "line %u FAILED: %s",
140                                 __LINE__, "Error sending packet for operation");
141                 status = TEST_FAILED;
142                 goto error_exit;
143         }
144
145         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
146                 rte_pause();
147
148         if (result_op == NULL) {
149                 RTE_LOG(ERR, USER1,
150                                 "line %u FAILED: %s",
151                                 __LINE__, "Failed to process asym crypto op");
152                 status = TEST_FAILED;
153                 goto error_exit;
154         }
155         status = TEST_SUCCESS;
156         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
157                 RTE_LOG(ERR, USER1,
158                                 "line %u FAILED: %s",
159                                 __LINE__, "Failed to process asym crypto op");
160                 status = TEST_FAILED;
161                 goto error_exit;
162         }
163
164 error_exit:
165
166         if (sess) {
167                 rte_cryptodev_asym_session_clear(dev_id, sess);
168                 rte_cryptodev_asym_session_free(sess);
169         }
170
171         if (op)
172                 rte_crypto_op_free(op);
173
174         TEST_ASSERT_EQUAL(status, 0, "Test failed");
175
176         return status;
177 }
178
179 static int
180 test_rsa_enc_dec(void)
181 {
182         struct crypto_testsuite_params *ts_params = &testsuite_params;
183         struct rte_mempool *op_mpool = ts_params->op_mpool;
184         struct rte_mempool *sess_mpool = ts_params->session_mpool;
185         uint8_t dev_id = ts_params->valid_devs[0];
186         struct rte_crypto_asym_op *asym_op = NULL;
187         struct rte_crypto_op *op = NULL, *result_op = NULL;
188         struct rte_cryptodev_asym_session *sess = NULL;
189         int status = TEST_SUCCESS;
190         uint8_t input_buf[TEST_DATA_SIZE] = {0};
191
192         sess = rte_cryptodev_asym_session_create(sess_mpool);
193
194         if (!sess) {
195                 RTE_LOG(ERR, USER1, "line %u "
196                                 "FAILED: %s", __LINE__,
197                                 "Session creation failed");
198                 status = TEST_FAILED;
199                 goto error_exit;
200         }
201
202         if (rte_cryptodev_asym_session_init(dev_id, sess, &rsa_xform,
203                                 sess_mpool) < 0) {
204                 RTE_LOG(ERR, USER1,
205                                 "line %u FAILED: %s",
206                                 __LINE__, "unabled to config sym session");
207                 status = TEST_FAILED;
208                 goto error_exit;
209         }
210
211         /* set up crypto op data structure */
212         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
213         if (!op) {
214                 RTE_LOG(ERR, USER1,
215                                 "line %u FAILED: %s",
216                                 __LINE__,
217                                 "Failed to allocate asymmetric crypto "
218                                 "operation struct");
219                 status = TEST_FAILED;
220                 goto error_exit;
221         }
222
223         asym_op = op->asym;
224         /*Compute encryption on the test vector */
225         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_ENCRYPT;
226
227         memcpy(input_buf, rsaplaintext.data,
228                         rsaplaintext.len);
229         asym_op->rsa.message.data = input_buf;
230         asym_op->rsa.message.length = rsaplaintext.len;
231         asym_op->rsa.pad = RTE_CRYPTO_RSA_PKCS1_V1_5_BT2;
232
233         debug_hexdump(stdout, "message", asym_op->rsa.message.data,
234                         asym_op->rsa.message.length);
235
236         /* attach asymmetric crypto session to crypto operations */
237         rte_crypto_op_attach_asym_session(op, sess);
238
239         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
240
241         /* Process crypto operation */
242         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
243                 RTE_LOG(ERR, USER1,
244                                 "line %u FAILED: %s",
245                                 __LINE__, "Error sending packet for operation");
246                 status = TEST_FAILED;
247                 goto error_exit;
248         }
249
250         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
251                 rte_pause();
252
253         if (result_op == NULL) {
254                 RTE_LOG(ERR, USER1,
255                                 "line %u FAILED: %s",
256                                 __LINE__, "Failed to process asym crypto op");
257                 status = TEST_FAILED;
258                 goto error_exit;
259         }
260         debug_hexdump(stdout, "encrypted message", asym_op->rsa.message.data,
261                         asym_op->rsa.message.length);
262         /* Use the resulted output as decryption Input vector*/
263         asym_op = result_op->asym;
264         asym_op->rsa.op_type = RTE_CRYPTO_ASYM_OP_DECRYPT;
265         asym_op->rsa.pad = RTE_CRYPTO_RSA_PKCS1_V1_5_BT1;
266
267         /* Process crypto operation */
268         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
269                 RTE_LOG(ERR, USER1,
270                                 "line %u FAILED: %s",
271                                 __LINE__, "Error sending packet for operation");
272                 status = TEST_FAILED;
273                 goto error_exit;
274         }
275
276         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
277                 rte_pause();
278
279         if (result_op == NULL) {
280                 RTE_LOG(ERR, USER1,
281                                 "line %u FAILED: %s",
282                                 __LINE__, "Failed to process asym crypto op");
283                 status = TEST_FAILED;
284                 goto error_exit;
285         }
286         status = TEST_SUCCESS;
287         int ret = 0;
288         ret = rsa_verify(&rsaplaintext, result_op);
289         if (ret)
290                 status = TEST_FAILED;
291
292 error_exit:
293
294         if (sess) {
295                 rte_cryptodev_asym_session_clear(dev_id, sess);
296                 rte_cryptodev_asym_session_free(sess);
297         }
298
299         if (op)
300                 rte_crypto_op_free(op);
301
302         TEST_ASSERT_EQUAL(status, 0, "Test failed");
303
304         return status;
305 }
306
307 static int
308 testsuite_setup(void)
309 {
310         struct crypto_testsuite_params *ts_params = &testsuite_params;
311         struct rte_cryptodev_info info;
312         uint32_t i = 0, nb_devs, dev_id;
313         int ret;
314         uint16_t qp_id;
315
316         memset(ts_params, 0, sizeof(*ts_params));
317
318         ts_params->op_mpool = rte_crypto_op_pool_create(
319                         "CRYPTO_ASYM_OP_POOL",
320                         RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
321                         TEST_NUM_BUFS, 0,
322                         0,
323                         rte_socket_id());
324         if (ts_params->op_mpool == NULL) {
325                 RTE_LOG(ERR, USER1, "Can't create ASYM_CRYPTO_OP_POOL\n");
326                 return TEST_FAILED;
327         }
328
329         /* Create an OPENSSL device if required */
330         if (gbl_driver_id == rte_cryptodev_driver_id_get(
331                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
332                 nb_devs = rte_cryptodev_device_count_by_driver(
333                                 rte_cryptodev_driver_id_get(
334                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
335                 if (nb_devs < 1) {
336                         ret = rte_vdev_init(
337                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
338                                 NULL);
339
340                         TEST_ASSERT(ret == 0, "Failed to create "
341                                 "instance of pmd : %s",
342                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
343                 }
344         }
345
346         nb_devs = rte_cryptodev_count();
347         if (nb_devs < 1) {
348                 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
349                 return TEST_FAILED;
350         }
351
352         /* Create list of valid crypto devs */
353         for (i = 0; i < nb_devs; i++) {
354                 rte_cryptodev_info_get(i, &info);
355                 if (info.driver_id == gbl_driver_id)
356                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
357         }
358
359         if (ts_params->valid_dev_count < 1)
360                 return TEST_FAILED;
361
362         /* Set up all the qps on the first of the valid devices found */
363
364         dev_id = ts_params->valid_devs[0];
365
366         rte_cryptodev_info_get(dev_id, &info);
367
368         /* check if device support asymmetric, skip if not */
369         if (!(info.feature_flags &
370                                 RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO)) {
371                 RTE_LOG(ERR, USER1, "Device doesn't support asymmetric. "
372                                 "Test Skipped.\n");
373                 return TEST_FAILED;
374         }
375
376         /* configure device with num qp */
377         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
378         ts_params->conf.socket_id = SOCKET_ID_ANY;
379         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
380                         &ts_params->conf),
381                         "Failed to configure cryptodev %u with %u qps",
382                         dev_id, ts_params->conf.nb_queue_pairs);
383
384         /* configure qp */
385         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
386         ts_params->qp_conf.mp_session = ts_params->session_mpool;
387         ts_params->qp_conf.mp_session_private = ts_params->session_mpool;
388         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
389                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
390                         dev_id, qp_id, &ts_params->qp_conf,
391                         rte_cryptodev_socket_id(dev_id)),
392                         "Failed to setup queue pair %u on cryptodev %u ASYM",
393                         qp_id, dev_id);
394         }
395
396         /* setup asym session pool */
397         unsigned int session_size =
398                 rte_cryptodev_asym_get_private_session_size(dev_id);
399         /*
400          * Create mempool with TEST_NUM_SESSIONS * 2,
401          * to include the session headers
402          */
403         ts_params->session_mpool = rte_mempool_create(
404                                 "test_asym_sess_mp",
405                                 TEST_NUM_SESSIONS * 2,
406                                 session_size,
407                                 0, 0, NULL, NULL, NULL,
408                                 NULL, SOCKET_ID_ANY,
409                                 0);
410
411         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
412                         "session mempool allocation failed");
413
414         return TEST_SUCCESS;
415 }
416
417 static void
418 testsuite_teardown(void)
419 {
420         struct crypto_testsuite_params *ts_params = &testsuite_params;
421
422         if (ts_params->op_mpool != NULL) {
423                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
424                 rte_mempool_avail_count(ts_params->op_mpool));
425         }
426
427         /* Free session mempools */
428         if (ts_params->session_mpool != NULL) {
429                 rte_mempool_free(ts_params->session_mpool);
430                 ts_params->session_mpool = NULL;
431         }
432 }
433
434 static int
435 ut_setup(void)
436 {
437         struct crypto_testsuite_params *ts_params = &testsuite_params;
438
439         uint16_t qp_id;
440
441         /* Reconfigure device to default parameters */
442         ts_params->conf.socket_id = SOCKET_ID_ANY;
443
444         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
445                         &ts_params->conf),
446                         "Failed to configure cryptodev %u",
447                         ts_params->valid_devs[0]);
448
449         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
450                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
451                         ts_params->valid_devs[0], qp_id,
452                         &ts_params->qp_conf,
453                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
454                         "Failed to setup queue pair %u on cryptodev %u",
455                         qp_id, ts_params->valid_devs[0]);
456         }
457
458         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
459
460         /* Start the device */
461         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
462                                                 "Failed to start cryptodev %u",
463                                                 ts_params->valid_devs[0]);
464
465         return TEST_SUCCESS;
466 }
467
468 static void
469 ut_teardown(void)
470 {
471         struct crypto_testsuite_params *ts_params = &testsuite_params;
472         struct rte_cryptodev_stats stats;
473
474         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
475
476         /* Stop the device */
477         rte_cryptodev_stop(ts_params->valid_devs[0]);
478 }
479
480 static inline void print_asym_capa(
481                 const struct rte_cryptodev_asymmetric_xform_capability *capa)
482 {
483         int i = 0;
484
485         printf("\nxform type: %s\n===================\n",
486                         rte_crypto_asym_xform_strings[capa->xform_type]);
487         printf("operation supported -");
488
489         for (i = 0; i < RTE_CRYPTO_ASYM_OP_LIST_END; i++) {
490                 /* check supported operations */
491                 if (rte_cryptodev_asym_xform_capability_check_optype(capa, i))
492                         printf(" %s",
493                                         rte_crypto_asym_op_strings[i]);
494                 }
495                 switch (capa->xform_type) {
496                 case RTE_CRYPTO_ASYM_XFORM_RSA:
497                 case RTE_CRYPTO_ASYM_XFORM_MODINV:
498                 case RTE_CRYPTO_ASYM_XFORM_MODEX:
499                 case RTE_CRYPTO_ASYM_XFORM_DH:
500                 case RTE_CRYPTO_ASYM_XFORM_DSA:
501                         printf(" modlen: min %d max %d increment %d\n",
502                                         capa->modlen.min,
503                                         capa->modlen.max,
504                                         capa->modlen.increment);
505                 break;
506                 default:
507                         break;
508                 }
509 }
510
511 static int
512 test_capability(void)
513 {
514         struct crypto_testsuite_params *ts_params = &testsuite_params;
515         uint8_t dev_id = ts_params->valid_devs[0];
516         struct rte_cryptodev_info dev_info;
517         const struct rte_cryptodev_capabilities *dev_capa;
518         int i = 0;
519         struct rte_cryptodev_asym_capability_idx idx;
520         const struct rte_cryptodev_asymmetric_xform_capability *capa;
521
522         rte_cryptodev_info_get(dev_id, &dev_info);
523         if (!(dev_info.feature_flags &
524                                 RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO)) {
525                 RTE_LOG(INFO, USER1,
526                                 "Device doesn't support asymmetric. Test Skipped\n");
527                 return TEST_SUCCESS;
528         }
529
530         /* print xform capability */
531         for (i = 0;
532                 dev_info.capabilities[i].op != RTE_CRYPTO_OP_TYPE_UNDEFINED;
533                 i++) {
534                 dev_capa = &(dev_info.capabilities[i]);
535                 if (dev_info.capabilities[i].op ==
536                                 RTE_CRYPTO_OP_TYPE_ASYMMETRIC) {
537                         idx.type = dev_capa->asym.xform_capa.xform_type;
538
539                         capa = rte_cryptodev_asym_capability_get(dev_id,
540                                 (const struct
541                                 rte_cryptodev_asym_capability_idx *) &idx);
542                         print_asym_capa(capa);
543                         }
544         }
545         return TEST_SUCCESS;
546 }
547
548 static int
549 test_dh_gen_shared_sec(struct rte_crypto_asym_xform *xfrm)
550 {
551         struct crypto_testsuite_params *ts_params = &testsuite_params;
552         struct rte_mempool *op_mpool = ts_params->op_mpool;
553         struct rte_mempool *sess_mpool = ts_params->session_mpool;
554         uint8_t dev_id = ts_params->valid_devs[0];
555         struct rte_crypto_asym_op *asym_op = NULL;
556         struct rte_crypto_op *op = NULL, *result_op = NULL;
557         struct rte_cryptodev_asym_session *sess = NULL;
558         int status = TEST_SUCCESS;
559         uint8_t output[TEST_DH_MOD_LEN];
560         struct rte_crypto_asym_xform xform = *xfrm;
561         uint8_t peer[] = "01234567890123456789012345678901234567890123456789";
562
563         sess = rte_cryptodev_asym_session_create(sess_mpool);
564         if (sess == NULL) {
565                 RTE_LOG(ERR, USER1,
566                                 "line %u FAILED: %s", __LINE__,
567                                 "Session creation failed");
568                 status = TEST_FAILED;
569                 goto error_exit;
570         }
571         /* set up crypto op data structure */
572         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
573         if (!op) {
574                 RTE_LOG(ERR, USER1,
575                         "line %u FAILED: %s",
576                         __LINE__, "Failed to allocate asymmetric crypto "
577                         "operation struct");
578                 status = TEST_FAILED;
579                 goto error_exit;
580         }
581         asym_op = op->asym;
582
583         /* Setup a xform and op to generate private key only */
584         xform.dh.type = RTE_CRYPTO_ASYM_OP_SHARED_SECRET_COMPUTE;
585         xform.next = NULL;
586         asym_op->dh.priv_key.data = dh_test_params.priv_key.data;
587         asym_op->dh.priv_key.length = dh_test_params.priv_key.length;
588         asym_op->dh.pub_key.data = (uint8_t *)peer;
589         asym_op->dh.pub_key.length = sizeof(peer);
590         asym_op->dh.shared_secret.data = output;
591         asym_op->dh.shared_secret.length = sizeof(output);
592
593         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
594                         sess_mpool) < 0) {
595                 RTE_LOG(ERR, USER1,
596                                 "line %u FAILED: %s",
597                                 __LINE__, "unabled to config sym session");
598                 status = TEST_FAILED;
599                 goto error_exit;
600         }
601
602         /* attach asymmetric crypto session to crypto operations */
603         rte_crypto_op_attach_asym_session(op, sess);
604
605         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
606
607         /* Process crypto operation */
608         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
609                 RTE_LOG(ERR, USER1,
610                         "line %u FAILED: %s",
611                         __LINE__, "Error sending packet for operation");
612                 status = TEST_FAILED;
613                 goto error_exit;
614         }
615
616         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
617                 rte_pause();
618
619         if (result_op == NULL) {
620                 RTE_LOG(ERR, USER1,
621                         "line %u FAILED: %s",
622                         __LINE__, "Failed to process asym crypto op");
623                 status = TEST_FAILED;
624                 goto error_exit;
625         }
626
627         debug_hexdump(stdout, "shared secret:",
628                         asym_op->dh.shared_secret.data,
629                         asym_op->dh.shared_secret.length);
630
631 error_exit:
632         if (sess != NULL) {
633                 rte_cryptodev_asym_session_clear(dev_id, sess);
634                 rte_cryptodev_asym_session_free(sess);
635         }
636         if (op != NULL)
637                 rte_crypto_op_free(op);
638         return status;
639 }
640
641 static int
642 test_dh_gen_priv_key(struct rte_crypto_asym_xform *xfrm)
643 {
644         struct crypto_testsuite_params *ts_params = &testsuite_params;
645         struct rte_mempool *op_mpool = ts_params->op_mpool;
646         struct rte_mempool *sess_mpool = ts_params->session_mpool;
647         uint8_t dev_id = ts_params->valid_devs[0];
648         struct rte_crypto_asym_op *asym_op = NULL;
649         struct rte_crypto_op *op = NULL, *result_op = NULL;
650         struct rte_cryptodev_asym_session *sess = NULL;
651         int status = TEST_SUCCESS;
652         uint8_t output[TEST_DH_MOD_LEN];
653         struct rte_crypto_asym_xform xform = *xfrm;
654
655         sess = rte_cryptodev_asym_session_create(sess_mpool);
656         if (sess == NULL) {
657                 RTE_LOG(ERR, USER1,
658                                  "line %u FAILED: %s", __LINE__,
659                                 "Session creation failed");
660                 status = TEST_FAILED;
661                 goto error_exit;
662         }
663         /* set up crypto op data structure */
664         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
665         if (!op) {
666                 RTE_LOG(ERR, USER1,
667                         "line %u FAILED: %s",
668                         __LINE__, "Failed to allocate asymmetric crypto "
669                         "operation struct");
670                 status = TEST_FAILED;
671                 goto error_exit;
672         }
673         asym_op = op->asym;
674
675         /* Setup a xform and op to generate private key only */
676         xform.dh.type = RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE;
677         xform.next = NULL;
678         asym_op->dh.priv_key.data = output;
679         asym_op->dh.priv_key.length = sizeof(output);
680
681         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
682                         sess_mpool) < 0) {
683                 RTE_LOG(ERR, USER1,
684                                 "line %u FAILED: %s",
685                                 __LINE__, "unabled to config sym session");
686                 status = TEST_FAILED;
687                 goto error_exit;
688         }
689
690         /* attach asymmetric crypto session to crypto operations */
691         rte_crypto_op_attach_asym_session(op, sess);
692
693         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
694
695         /* Process crypto operation */
696         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
697                 RTE_LOG(ERR, USER1,
698                         "line %u FAILED: %s",
699                         __LINE__, "Error sending packet for operation");
700                 status = TEST_FAILED;
701                 goto error_exit;
702         }
703
704         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
705                 rte_pause();
706
707         if (result_op == NULL) {
708                 RTE_LOG(ERR, USER1,
709                         "line %u FAILED: %s",
710                         __LINE__, "Failed to process asym crypto op");
711                 status = TEST_FAILED;
712                 goto error_exit;
713         }
714
715         debug_hexdump(stdout, "private key:",
716                         asym_op->dh.priv_key.data,
717                         asym_op->dh.priv_key.length);
718
719
720 error_exit:
721         if (sess != NULL) {
722                 rte_cryptodev_asym_session_clear(dev_id, sess);
723                 rte_cryptodev_asym_session_free(sess);
724         }
725         if (op != NULL)
726                 rte_crypto_op_free(op);
727
728         return status;
729 }
730
731
732 static int
733 test_dh_gen_pub_key(struct rte_crypto_asym_xform *xfrm)
734 {
735         struct crypto_testsuite_params *ts_params = &testsuite_params;
736         struct rte_mempool *op_mpool = ts_params->op_mpool;
737         struct rte_mempool *sess_mpool = ts_params->session_mpool;
738         uint8_t dev_id = ts_params->valid_devs[0];
739         struct rte_crypto_asym_op *asym_op = NULL;
740         struct rte_crypto_op *op = NULL, *result_op = NULL;
741         struct rte_cryptodev_asym_session *sess = NULL;
742         int status = TEST_SUCCESS;
743         uint8_t output[TEST_DH_MOD_LEN];
744         struct rte_crypto_asym_xform xform = *xfrm;
745
746         sess = rte_cryptodev_asym_session_create(sess_mpool);
747         if (sess == NULL) {
748                 RTE_LOG(ERR, USER1,
749                                  "line %u FAILED: %s", __LINE__,
750                                 "Session creation failed");
751                 status = TEST_FAILED;
752                 goto error_exit;
753         }
754         /* set up crypto op data structure */
755         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
756         if (!op) {
757                 RTE_LOG(ERR, USER1,
758                         "line %u FAILED: %s",
759                         __LINE__, "Failed to allocate asymmetric crypto "
760                         "operation struct");
761                 status = TEST_FAILED;
762                 goto error_exit;
763         }
764         asym_op = op->asym;
765         /* Setup a xform chain to generate public key
766          * using test private key
767          *
768          */
769         xform.dh.type = RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE;
770         xform.next = NULL;
771
772         asym_op->dh.pub_key.data = output;
773         asym_op->dh.pub_key.length = sizeof(output);
774         /* load pre-defined private key */
775         asym_op->dh.priv_key.data = rte_malloc(NULL,
776                                         dh_test_params.priv_key.length,
777                                         0);
778         asym_op->dh.priv_key = dh_test_params.priv_key;
779
780         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
781                         sess_mpool) < 0) {
782                 RTE_LOG(ERR, USER1,
783                                 "line %u FAILED: %s",
784                                 __LINE__, "unabled to config sym session");
785                 status = TEST_FAILED;
786                 goto error_exit;
787         }
788
789         /* attach asymmetric crypto session to crypto operations */
790         rte_crypto_op_attach_asym_session(op, sess);
791
792         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
793
794         /* Process crypto operation */
795         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
796                 RTE_LOG(ERR, USER1,
797                         "line %u FAILED: %s",
798                         __LINE__, "Error sending packet for operation");
799                 status = TEST_FAILED;
800                 goto error_exit;
801         }
802
803         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
804                 rte_pause();
805
806         if (result_op == NULL) {
807                 RTE_LOG(ERR, USER1,
808                         "line %u FAILED: %s",
809                         __LINE__, "Failed to process asym crypto op");
810                 status = TEST_FAILED;
811                 goto error_exit;
812         }
813
814         debug_hexdump(stdout, "pub key:",
815                         asym_op->dh.pub_key.data, asym_op->dh.pub_key.length);
816
817         debug_hexdump(stdout, "priv key:",
818                         asym_op->dh.priv_key.data, asym_op->dh.priv_key.length);
819
820 error_exit:
821         if (sess != NULL) {
822                 rte_cryptodev_asym_session_clear(dev_id, sess);
823                 rte_cryptodev_asym_session_free(sess);
824         }
825         if (op != NULL)
826                 rte_crypto_op_free(op);
827
828         return status;
829 }
830
831 static int
832 test_dh_gen_kp(struct rte_crypto_asym_xform *xfrm)
833 {
834         struct crypto_testsuite_params *ts_params = &testsuite_params;
835         struct rte_mempool *op_mpool = ts_params->op_mpool;
836         struct rte_mempool *sess_mpool = ts_params->session_mpool;
837         uint8_t dev_id = ts_params->valid_devs[0];
838         struct rte_crypto_asym_op *asym_op = NULL;
839         struct rte_crypto_op *op = NULL, *result_op = NULL;
840         struct rte_cryptodev_asym_session *sess = NULL;
841         int status = TEST_SUCCESS;
842         uint8_t out_pub_key[TEST_DH_MOD_LEN];
843         uint8_t out_prv_key[TEST_DH_MOD_LEN];
844         struct rte_crypto_asym_xform pub_key_xform;
845         struct rte_crypto_asym_xform xform = *xfrm;
846
847         sess = rte_cryptodev_asym_session_create(sess_mpool);
848         if (sess == NULL) {
849                 RTE_LOG(ERR, USER1,
850                                  "line %u FAILED: %s", __LINE__,
851                                 "Session creation failed");
852                 status = TEST_FAILED;
853                 goto error_exit;
854         }
855
856         /* set up crypto op data structure */
857         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
858         if (!op) {
859                 RTE_LOG(ERR, USER1,
860                         "line %u FAILED: %s",
861                         __LINE__, "Failed to allocate asymmetric crypto "
862                         "operation struct");
863                 status = TEST_FAILED;
864                 goto error_exit;
865         }
866         asym_op = op->asym;
867         /* Setup a xform chain to generate
868          * private key first followed by
869          * public key
870          */xform.dh.type = RTE_CRYPTO_ASYM_OP_PRIVATE_KEY_GENERATE;
871         pub_key_xform.xform_type = RTE_CRYPTO_ASYM_XFORM_DH;
872         pub_key_xform.dh.type = RTE_CRYPTO_ASYM_OP_PUBLIC_KEY_GENERATE;
873         xform.next = &pub_key_xform;
874
875         asym_op->dh.pub_key.data = out_pub_key;
876         asym_op->dh.pub_key.length = sizeof(out_pub_key);
877         asym_op->dh.priv_key.data = out_prv_key;
878         asym_op->dh.priv_key.length = sizeof(out_prv_key);
879         if (rte_cryptodev_asym_session_init(dev_id, sess, &xform,
880                         sess_mpool) < 0) {
881                 RTE_LOG(ERR, USER1,
882                                 "line %u FAILED: %s",
883                                 __LINE__, "unabled to config sym session");
884                 status = TEST_FAILED;
885                 goto error_exit;
886         }
887
888         /* attach asymmetric crypto session to crypto operations */
889         rte_crypto_op_attach_asym_session(op, sess);
890
891         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
892
893         /* Process crypto operation */
894         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
895                 RTE_LOG(ERR, USER1,
896                         "line %u FAILED: %s",
897                         __LINE__, "Error sending packet for operation");
898                 status = TEST_FAILED;
899                 goto error_exit;
900         }
901
902         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
903                 rte_pause();
904
905         if (result_op == NULL) {
906                 RTE_LOG(ERR, USER1,
907                         "line %u FAILED: %s",
908                         __LINE__, "Failed to process asym crypto op");
909                 status = TEST_FAILED;
910                 goto error_exit;
911         }
912         debug_hexdump(stdout, "priv key:",
913                         out_prv_key, asym_op->dh.priv_key.length);
914         debug_hexdump(stdout, "pub key:",
915                         out_pub_key, asym_op->dh.pub_key.length);
916
917 error_exit:
918         if (sess != NULL) {
919                 rte_cryptodev_asym_session_clear(dev_id, sess);
920                 rte_cryptodev_asym_session_free(sess);
921         }
922         if (op != NULL)
923                 rte_crypto_op_free(op);
924
925         return status;
926 }
927
928 static int
929 test_mod_inv(void)
930 {
931         struct crypto_testsuite_params *ts_params = &testsuite_params;
932         struct rte_mempool *op_mpool = ts_params->op_mpool;
933         struct rte_mempool *sess_mpool = ts_params->session_mpool;
934         uint8_t dev_id = ts_params->valid_devs[0];
935         struct rte_crypto_asym_op *asym_op = NULL;
936         struct rte_crypto_op *op = NULL, *result_op = NULL;
937         struct rte_cryptodev_asym_session *sess = NULL;
938         int status = TEST_SUCCESS;
939         struct rte_cryptodev_asym_capability_idx cap_idx;
940         const struct rte_cryptodev_asymmetric_xform_capability *capability;
941         uint8_t input[TEST_DATA_SIZE] = {0};
942         int ret = 0;
943
944         if (rte_cryptodev_asym_get_xform_enum(
945                 &modinv_xform.xform_type, "modinv") < 0) {
946                 RTE_LOG(ERR, USER1,
947                                  "Invalid ASYNC algorithm specified\n");
948                 return -1;
949         }
950
951         cap_idx.type = modinv_xform.xform_type;
952         capability = rte_cryptodev_asym_capability_get(dev_id,
953                                         &cap_idx);
954
955         if (rte_cryptodev_asym_xform_capability_check_modlen(
956                 capability,
957                 modinv_xform.modinv.modulus.length)) {
958                 RTE_LOG(ERR, USER1,
959                                  "Invalid MODULOUS length specified\n");
960                                 return -1;
961                 }
962
963         sess = rte_cryptodev_asym_session_create(sess_mpool);
964         if (!sess) {
965                 RTE_LOG(ERR, USER1, "line %u "
966                                 "FAILED: %s", __LINE__,
967                                 "Session creation failed");
968                 status = TEST_FAILED;
969                 goto error_exit;
970         }
971
972         if (rte_cryptodev_asym_session_init(dev_id, sess, &modinv_xform,
973                         sess_mpool) < 0) {
974                 RTE_LOG(ERR, USER1,
975                                 "line %u FAILED: %s",
976                                 __LINE__, "unabled to config sym session");
977                 status = TEST_FAILED;
978                 goto error_exit;
979         }
980
981         /* generate crypto op data structure */
982         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
983         if (!op) {
984                 RTE_LOG(ERR, USER1,
985                         "line %u FAILED: %s",
986                         __LINE__, "Failed to allocate asymmetric crypto "
987                         "operation struct");
988                 status = TEST_FAILED;
989                 goto error_exit;
990         }
991
992         asym_op = op->asym;
993         memcpy(input, base, sizeof(base));
994         asym_op->modinv.base.data = input;
995         asym_op->modinv.base.length = sizeof(base);
996
997         /* attach asymmetric crypto session to crypto operations */
998         rte_crypto_op_attach_asym_session(op, sess);
999
1000         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1001
1002         /* Process crypto operation */
1003         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1004                 RTE_LOG(ERR, USER1,
1005                         "line %u FAILED: %s",
1006                         __LINE__, "Error sending packet for operation");
1007                 status = TEST_FAILED;
1008                 goto error_exit;
1009         }
1010
1011         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1012                 rte_pause();
1013
1014         if (result_op == NULL) {
1015                 RTE_LOG(ERR, USER1,
1016                                 "line %u FAILED: %s",
1017                                 __LINE__, "Failed to process asym crypto op");
1018                 status = TEST_FAILED;
1019                 goto error_exit;
1020         }
1021
1022         ret = verify_modinv(mod_inv, result_op);
1023         if (ret) {
1024                 RTE_LOG(ERR, USER1,
1025                          "operation verification failed\n");
1026                 status = TEST_FAILED;
1027         }
1028
1029 error_exit:
1030         if (sess) {
1031                 rte_cryptodev_asym_session_clear(dev_id, sess);
1032                 rte_cryptodev_asym_session_free(sess);
1033         }
1034
1035         if (op)
1036                 rte_crypto_op_free(op);
1037
1038         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1039
1040         return status;
1041 }
1042
1043 static int
1044 test_mod_exp(void)
1045 {
1046         struct crypto_testsuite_params *ts_params = &testsuite_params;
1047         struct rte_mempool *op_mpool = ts_params->op_mpool;
1048         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1049         uint8_t dev_id = ts_params->valid_devs[0];
1050         struct rte_crypto_asym_op *asym_op = NULL;
1051         struct rte_crypto_op *op = NULL, *result_op = NULL;
1052         struct rte_cryptodev_asym_session *sess = NULL;
1053         int status = TEST_SUCCESS;
1054         struct rte_cryptodev_asym_capability_idx cap_idx;
1055         const struct rte_cryptodev_asymmetric_xform_capability *capability;
1056         uint8_t input[TEST_DATA_SIZE] = {0};
1057         int ret = 0;
1058
1059         if (rte_cryptodev_asym_get_xform_enum(&modex_xform.xform_type,
1060                 "modexp")
1061                 < 0) {
1062                 RTE_LOG(ERR, USER1,
1063                                 "Invalid ASYNC algorithm specified\n");
1064                 return -1;
1065         }
1066
1067         /* check for modlen capability */
1068         cap_idx.type = modex_xform.xform_type;
1069         capability = rte_cryptodev_asym_capability_get(dev_id, &cap_idx);
1070
1071         if (rte_cryptodev_asym_xform_capability_check_modlen(
1072                         capability, modex_xform.modex.modulus.length)) {
1073                 RTE_LOG(ERR, USER1,
1074                                 "Invalid MODULOUS length specified\n");
1075                                 return -1;
1076                 }
1077
1078         /* generate crypto op data structure */
1079         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1080         if (!op) {
1081                 RTE_LOG(ERR, USER1,
1082                         "line %u FAILED: %s",
1083                         __LINE__, "Failed to allocate asymmetric crypto "
1084                         "operation struct");
1085                 status = TEST_FAILED;
1086                 goto error_exit;
1087         }
1088
1089         sess = rte_cryptodev_asym_session_create(sess_mpool);
1090         if (!sess) {
1091                 RTE_LOG(ERR, USER1,
1092                                  "line %u "
1093                                 "FAILED: %s", __LINE__,
1094                                 "Session creation failed");
1095                 status = TEST_FAILED;
1096                 goto error_exit;
1097         }
1098
1099         if (rte_cryptodev_asym_session_init(dev_id, sess, &modex_xform,
1100                         sess_mpool) < 0) {
1101                 RTE_LOG(ERR, USER1,
1102                                 "line %u FAILED: %s",
1103                                 __LINE__, "unabled to config sym session");
1104                 status = TEST_FAILED;
1105                 goto error_exit;
1106         }
1107
1108         asym_op = op->asym;
1109         memcpy(input, base, sizeof(base));
1110         asym_op->modex.base.data = input;
1111         asym_op->modex.base.length = sizeof(base);
1112         /* attach asymmetric crypto session to crypto operations */
1113         rte_crypto_op_attach_asym_session(op, sess);
1114
1115         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1116         /* Process crypto operation */
1117         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1118                 RTE_LOG(ERR, USER1,
1119                                 "line %u FAILED: %s",
1120                                 __LINE__, "Error sending packet for operation");
1121                 status = TEST_FAILED;
1122                 goto error_exit;
1123         }
1124
1125         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1126                 rte_pause();
1127
1128         if (result_op == NULL) {
1129                 RTE_LOG(ERR, USER1,
1130                                 "line %u FAILED: %s",
1131                                 __LINE__, "Failed to process asym crypto op");
1132                 status = TEST_FAILED;
1133                 goto error_exit;
1134         }
1135
1136         ret = verify_modexp(mod_exp, result_op);
1137         if (ret) {
1138                 RTE_LOG(ERR, USER1,
1139                          "operation verification failed\n");
1140                 status = TEST_FAILED;
1141         }
1142
1143 error_exit:
1144         if (sess != NULL) {
1145                 rte_cryptodev_asym_session_clear(dev_id, sess);
1146                 rte_cryptodev_asym_session_free(sess);
1147         }
1148
1149         if (op != NULL)
1150                 rte_crypto_op_free(op);
1151
1152         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1153
1154         return status;
1155 }
1156
1157 static int
1158 test_dh_keygenration(void)
1159 {
1160         int status;
1161
1162         debug_hexdump(stdout, "p:", dh_xform.dh.p.data, dh_xform.dh.p.length);
1163         debug_hexdump(stdout, "g:", dh_xform.dh.g.data, dh_xform.dh.g.length);
1164         debug_hexdump(stdout, "priv_key:", dh_test_params.priv_key.data,
1165                         dh_test_params.priv_key.length);
1166
1167         RTE_LOG(INFO, USER1,
1168                 "Test Public and Private key pair generation\n");
1169
1170         status = test_dh_gen_kp(&dh_xform);
1171         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1172
1173         RTE_LOG(INFO, USER1,
1174                 "Test Public Key Generation using pre-defined priv key\n");
1175
1176         status = test_dh_gen_pub_key(&dh_xform);
1177         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1178
1179         RTE_LOG(INFO, USER1,
1180                 "Test Private Key Generation only\n");
1181
1182         status = test_dh_gen_priv_key(&dh_xform);
1183         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1184
1185         RTE_LOG(INFO, USER1,
1186                 "Test shared secret compute\n");
1187
1188         status = test_dh_gen_shared_sec(&dh_xform);
1189         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1190
1191         return status;
1192 }
1193
1194 static int
1195 test_dsa_sign(void)
1196 {
1197         struct crypto_testsuite_params *ts_params = &testsuite_params;
1198         struct rte_mempool *op_mpool = ts_params->op_mpool;
1199         struct rte_mempool *sess_mpool = ts_params->session_mpool;
1200         uint8_t dev_id = ts_params->valid_devs[0];
1201         struct rte_crypto_asym_op *asym_op = NULL;
1202         struct rte_crypto_op *op = NULL, *result_op = NULL;
1203         struct rte_cryptodev_asym_session *sess = NULL;
1204         int status = TEST_SUCCESS;
1205         uint8_t r[TEST_DH_MOD_LEN];
1206         uint8_t s[TEST_DH_MOD_LEN];
1207         uint8_t dgst[] = "35d81554afaad2cf18f3a1770d5fedc4ea5be344";
1208
1209         sess = rte_cryptodev_asym_session_create(sess_mpool);
1210         if (sess == NULL) {
1211                 RTE_LOG(ERR, USER1,
1212                                  "line %u FAILED: %s", __LINE__,
1213                                 "Session creation failed");
1214                 status = TEST_FAILED;
1215                 goto error_exit;
1216         }
1217         /* set up crypto op data structure */
1218         op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_ASYMMETRIC);
1219         if (!op) {
1220                 RTE_LOG(ERR, USER1,
1221                         "line %u FAILED: %s",
1222                         __LINE__, "Failed to allocate asymmetric crypto "
1223                         "operation struct");
1224                 status = TEST_FAILED;
1225                 goto error_exit;
1226         }
1227         asym_op = op->asym;
1228
1229         debug_hexdump(stdout, "p: ", dsa_xform.dsa.p.data,
1230                         dsa_xform.dsa.p.length);
1231         debug_hexdump(stdout, "q: ", dsa_xform.dsa.q.data,
1232                         dsa_xform.dsa.q.length);
1233         debug_hexdump(stdout, "g: ", dsa_xform.dsa.g.data,
1234                         dsa_xform.dsa.g.length);
1235         debug_hexdump(stdout, "priv_key: ", dsa_xform.dsa.x.data,
1236                         dsa_xform.dsa.x.length);
1237
1238         if (rte_cryptodev_asym_session_init(dev_id, sess, &dsa_xform,
1239                                 sess_mpool) < 0) {
1240                 RTE_LOG(ERR, USER1,
1241                                 "line %u FAILED: %s",
1242                                 __LINE__, "unabled to config sym session");
1243                 status = TEST_FAILED;
1244                 goto error_exit;
1245         }
1246
1247         /* attach asymmetric crypto session to crypto operations */
1248         rte_crypto_op_attach_asym_session(op, sess);
1249         asym_op->dsa.op_type = RTE_CRYPTO_ASYM_OP_SIGN;
1250         asym_op->dsa.message.data = dgst;
1251         asym_op->dsa.message.length = sizeof(dgst);
1252         asym_op->dsa.r.length = sizeof(r);
1253         asym_op->dsa.r.data = r;
1254         asym_op->dsa.s.length = sizeof(s);
1255         asym_op->dsa.s.data = s;
1256
1257         RTE_LOG(DEBUG, USER1, "Process ASYM operation");
1258
1259         /* Process crypto operation */
1260         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1261                 RTE_LOG(ERR, USER1,
1262                         "line %u FAILED: %s",
1263                         __LINE__, "Error sending packet for operation");
1264                 status = TEST_FAILED;
1265                 goto error_exit;
1266         }
1267
1268         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1269                 rte_pause();
1270
1271         if (result_op == NULL) {
1272                 RTE_LOG(ERR, USER1,
1273                         "line %u FAILED: %s",
1274                         __LINE__, "Failed to process asym crypto op");
1275                 status = TEST_FAILED;
1276                 goto error_exit;
1277         }
1278
1279         asym_op = result_op->asym;
1280
1281         debug_hexdump(stdout, "r:",
1282                         asym_op->dsa.r.data, asym_op->dsa.r.length);
1283         debug_hexdump(stdout, "s:",
1284                         asym_op->dsa.s.data, asym_op->dsa.s.length);
1285
1286         /* Test PMD DSA sign verification using signer public key */
1287         asym_op->dsa.op_type = RTE_CRYPTO_ASYM_OP_VERIFY;
1288
1289         /* copy signer public key */
1290         asym_op->dsa.y.data = dsa_test_params.y.data;
1291         asym_op->dsa.y.length = dsa_test_params.y.length;
1292
1293         /* Process crypto operation */
1294         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
1295                 RTE_LOG(ERR, USER1,
1296                         "line %u FAILED: %s",
1297                         __LINE__, "Error sending packet for operation");
1298                 status = TEST_FAILED;
1299                 goto error_exit;
1300         }
1301
1302         while (rte_cryptodev_dequeue_burst(dev_id, 0, &result_op, 1) == 0)
1303                 rte_pause();
1304
1305         if (result_op == NULL) {
1306                 RTE_LOG(ERR, USER1,
1307                         "line %u FAILED: %s",
1308                         __LINE__, "Failed to process asym crypto op");
1309                 status = TEST_FAILED;
1310                 goto error_exit;
1311         }
1312
1313         if (result_op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
1314                 RTE_LOG(ERR, USER1,
1315                                 "line %u FAILED: %s",
1316                                 __LINE__, "Failed to process asym crypto op");
1317                 status = TEST_FAILED;
1318         }
1319 error_exit:
1320         if (sess != NULL) {
1321                 rte_cryptodev_asym_session_clear(dev_id, sess);
1322                 rte_cryptodev_asym_session_free(sess);
1323         }
1324         if (op != NULL)
1325                 rte_crypto_op_free(op);
1326         return status;
1327 }
1328
1329 static int
1330 test_dsa(void)
1331 {
1332         int status;
1333         status = test_dsa_sign();
1334         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1335         return status;
1336 }
1337
1338
1339 static struct unit_test_suite cryptodev_openssl_asym_testsuite  = {
1340         .suite_name = "Crypto Device OPENSSL ASYM Unit Test Suite",
1341         .setup = testsuite_setup,
1342         .teardown = testsuite_teardown,
1343         .unit_test_cases = {
1344                 TEST_CASE_ST(ut_setup, ut_teardown, test_capability),
1345                 TEST_CASE_ST(ut_setup, ut_teardown, test_dsa),
1346                 TEST_CASE_ST(ut_setup, ut_teardown, test_dh_keygenration),
1347                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_enc_dec),
1348                 TEST_CASE_ST(ut_setup, ut_teardown, test_rsa_sign_verify),
1349                 TEST_CASE_ST(ut_setup, ut_teardown, test_mod_inv),
1350                 TEST_CASE_ST(ut_setup, ut_teardown, test_mod_exp),
1351                 TEST_CASES_END() /**< NULL terminate unit test array */
1352         }
1353 };
1354
1355 static int
1356 test_cryptodev_openssl_asym(void)
1357 {
1358         gbl_driver_id = rte_cryptodev_driver_id_get(
1359                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
1360
1361         if (gbl_driver_id == -1) {
1362                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
1363                                 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
1364                                 "in config file to run this testsuite.\n");
1365                 return TEST_FAILED;
1366         }
1367
1368         return unit_test_suite_runner(&cryptodev_openssl_asym_testsuite);
1369 }
1370
1371 REGISTER_TEST_COMMAND(cryptodev_openssl_asym_autotest,
1372                                           test_cryptodev_openssl_asym);