1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(C) 2021 Marvell.
8 #include <rte_common.h>
9 #include <rte_crypto_asym.h>
10 #include <rte_malloc.h>
13 #include "cnxk_cryptodev_ops.h"
16 enum rte_crypto_asym_xform_type xfrm_type;
18 struct rte_crypto_rsa_xform rsa_ctx;
19 struct rte_crypto_modex_xform mod_ctx;
20 struct roc_ae_ec_ctx ec_ctx;
22 uint64_t *cnxk_fpm_iova;
23 struct roc_ae_ec_group **ec_grp;
27 static __rte_always_inline void
28 cnxk_ae_modex_param_normalize(uint8_t **data, size_t *len)
32 /* Strip leading NUL bytes */
33 for (i = 0; i < *len; i++) {
41 static __rte_always_inline int
42 cnxk_ae_fill_modex_params(struct cnxk_ae_sess *sess,
43 struct rte_crypto_asym_xform *xform)
45 struct rte_crypto_modex_xform *ctx = &sess->mod_ctx;
46 size_t exp_len = xform->modex.exponent.length;
47 size_t mod_len = xform->modex.modulus.length;
48 uint8_t *exp = xform->modex.exponent.data;
49 uint8_t *mod = xform->modex.modulus.data;
51 cnxk_ae_modex_param_normalize(&mod, &mod_len);
52 cnxk_ae_modex_param_normalize(&exp, &exp_len);
54 if (unlikely(exp_len == 0 || mod_len == 0))
57 if (unlikely(exp_len > mod_len))
60 /* Allocate buffer to hold modexp params */
61 ctx->modulus.data = rte_malloc(NULL, mod_len + exp_len, 0);
62 if (ctx->modulus.data == NULL)
65 /* Set up modexp prime modulus and private exponent */
66 memcpy(ctx->modulus.data, mod, mod_len);
67 ctx->exponent.data = ctx->modulus.data + mod_len;
68 memcpy(ctx->exponent.data, exp, exp_len);
70 ctx->modulus.length = mod_len;
71 ctx->exponent.length = exp_len;
76 static __rte_always_inline int
77 cnxk_ae_fill_rsa_params(struct cnxk_ae_sess *sess,
78 struct rte_crypto_asym_xform *xform)
80 struct rte_crypto_rsa_priv_key_qt qt = xform->rsa.qt;
81 struct rte_crypto_rsa_xform *xfrm_rsa = &xform->rsa;
82 struct rte_crypto_rsa_xform *rsa = &sess->rsa_ctx;
83 size_t mod_len = xfrm_rsa->n.length;
84 size_t exp_len = xfrm_rsa->e.length;
88 if (qt.p.length != 0 && qt.p.data == NULL)
91 /* Make sure key length used is not more than mod_len/2 */
92 if (qt.p.data != NULL)
93 len = (((mod_len / 2) < qt.p.length) ? 0 : qt.p.length);
95 /* Total size required for RSA key params(n,e,(q,dQ,p,dP,qInv)) */
96 total_size = mod_len + exp_len + 5 * len;
98 /* Allocate buffer to hold all RSA keys */
99 rsa->n.data = rte_malloc(NULL, total_size, 0);
100 if (rsa->n.data == NULL)
103 /* Set up RSA prime modulus and public key exponent */
104 memcpy(rsa->n.data, xfrm_rsa->n.data, mod_len);
105 rsa->e.data = rsa->n.data + mod_len;
106 memcpy(rsa->e.data, xfrm_rsa->e.data, exp_len);
108 /* Private key in quintuple format */
110 rsa->qt.q.data = rsa->e.data + exp_len;
111 memcpy(rsa->qt.q.data, qt.q.data, qt.q.length);
112 rsa->qt.dQ.data = rsa->qt.q.data + qt.q.length;
113 memcpy(rsa->qt.dQ.data, qt.dQ.data, qt.dQ.length);
114 rsa->qt.p.data = rsa->qt.dQ.data + qt.dQ.length;
115 if (qt.p.data != NULL)
116 memcpy(rsa->qt.p.data, qt.p.data, qt.p.length);
117 rsa->qt.dP.data = rsa->qt.p.data + qt.p.length;
118 memcpy(rsa->qt.dP.data, qt.dP.data, qt.dP.length);
119 rsa->qt.qInv.data = rsa->qt.dP.data + qt.dP.length;
120 memcpy(rsa->qt.qInv.data, qt.qInv.data, qt.qInv.length);
122 rsa->qt.q.length = qt.q.length;
123 rsa->qt.dQ.length = qt.dQ.length;
124 rsa->qt.p.length = qt.p.length;
125 rsa->qt.dP.length = qt.dP.length;
126 rsa->qt.qInv.length = qt.qInv.length;
128 rsa->n.length = mod_len;
129 rsa->e.length = exp_len;
134 static __rte_always_inline int
135 cnxk_ae_fill_ec_params(struct cnxk_ae_sess *sess,
136 struct rte_crypto_asym_xform *xform)
138 struct roc_ae_ec_ctx *ec = &sess->ec_ctx;
140 switch (xform->ec.curve_id) {
141 case RTE_CRYPTO_EC_GROUP_SECP192R1:
142 ec->curveid = ROC_AE_EC_ID_P192;
144 case RTE_CRYPTO_EC_GROUP_SECP224R1:
145 ec->curveid = ROC_AE_EC_ID_P224;
147 case RTE_CRYPTO_EC_GROUP_SECP256R1:
148 ec->curveid = ROC_AE_EC_ID_P256;
150 case RTE_CRYPTO_EC_GROUP_SECP384R1:
151 ec->curveid = ROC_AE_EC_ID_P384;
153 case RTE_CRYPTO_EC_GROUP_SECP521R1:
154 ec->curveid = ROC_AE_EC_ID_P521;
157 /* Only NIST curves (FIPS 186-4) are supported */
164 static __rte_always_inline int
165 cnxk_ae_fill_session_parameters(struct cnxk_ae_sess *sess,
166 struct rte_crypto_asym_xform *xform)
170 sess->xfrm_type = xform->xform_type;
172 switch (xform->xform_type) {
173 case RTE_CRYPTO_ASYM_XFORM_RSA:
174 ret = cnxk_ae_fill_rsa_params(sess, xform);
176 case RTE_CRYPTO_ASYM_XFORM_MODEX:
177 ret = cnxk_ae_fill_modex_params(sess, xform);
179 case RTE_CRYPTO_ASYM_XFORM_ECDSA:
181 case RTE_CRYPTO_ASYM_XFORM_ECPM:
182 ret = cnxk_ae_fill_ec_params(sess, xform);
191 cnxk_ae_free_session_parameters(struct cnxk_ae_sess *sess)
193 struct rte_crypto_modex_xform *mod;
194 struct rte_crypto_rsa_xform *rsa;
196 switch (sess->xfrm_type) {
197 case RTE_CRYPTO_ASYM_XFORM_RSA:
198 rsa = &sess->rsa_ctx;
199 rte_free(rsa->n.data);
201 case RTE_CRYPTO_ASYM_XFORM_MODEX:
202 mod = &sess->mod_ctx;
203 rte_free(mod->modulus.data);
205 case RTE_CRYPTO_ASYM_XFORM_ECDSA:
207 case RTE_CRYPTO_ASYM_XFORM_ECPM:
214 static __rte_always_inline int
215 cnxk_ae_modex_prep(struct rte_crypto_op *op, struct roc_ae_buf_ptr *meta_buf,
216 struct rte_crypto_modex_xform *mod, struct cpt_inst_s *inst)
218 uint32_t exp_len = mod->exponent.length;
219 uint32_t mod_len = mod->modulus.length;
220 struct rte_crypto_mod_op_param mod_op;
221 uint64_t total_key_len;
222 union cpt_inst_w4 w4;
227 mod_op = op->asym->modex;
229 base_len = mod_op.base.length;
230 if (unlikely(base_len > mod_len)) {
231 op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
235 total_key_len = mod_len + exp_len;
238 dptr = meta_buf->vaddr;
239 inst->dptr = (uintptr_t)dptr;
240 memcpy(dptr, mod->modulus.data, total_key_len);
241 dptr += total_key_len;
242 memcpy(dptr, mod_op.base.data, base_len);
244 dlen = total_key_len + base_len;
247 w4.s.opcode_major = ROC_AE_MAJOR_OP_MODEX;
248 w4.s.opcode_minor = ROC_AE_MINOR_OP_MODEX;
250 w4.s.param1 = mod_len;
251 w4.s.param2 = exp_len;
254 inst->w4.u64 = w4.u64;
255 inst->rptr = (uintptr_t)dptr;
260 static __rte_always_inline void
261 cnxk_ae_rsa_prep(struct rte_crypto_op *op, struct roc_ae_buf_ptr *meta_buf,
262 struct rte_crypto_rsa_xform *rsa,
263 rte_crypto_param *crypto_param, struct cpt_inst_s *inst)
265 struct rte_crypto_rsa_op_param rsa_op;
266 uint32_t mod_len = rsa->n.length;
267 uint32_t exp_len = rsa->e.length;
268 uint64_t total_key_len;
269 union cpt_inst_w4 w4;
274 rsa_op = op->asym->rsa;
275 total_key_len = mod_len + exp_len;
278 dptr = meta_buf->vaddr;
279 inst->dptr = (uintptr_t)dptr;
280 memcpy(dptr, rsa->n.data, total_key_len);
281 dptr += total_key_len;
283 in_size = crypto_param->length;
284 memcpy(dptr, crypto_param->data, in_size);
287 dlen = total_key_len + in_size;
289 if (rsa_op.pad == RTE_CRYPTO_RSA_PADDING_NONE) {
290 /* Use mod_exp operation for no_padding type */
291 w4.s.opcode_minor = ROC_AE_MINOR_OP_MODEX;
292 w4.s.param2 = exp_len;
294 if (rsa_op.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT) {
295 w4.s.opcode_minor = ROC_AE_MINOR_OP_PKCS_ENC;
296 /* Public key encrypt, use BT2*/
297 w4.s.param2 = ROC_AE_CPT_BLOCK_TYPE2 |
298 ((uint16_t)(exp_len) << 1);
299 } else if (rsa_op.op_type == RTE_CRYPTO_ASYM_OP_VERIFY) {
300 w4.s.opcode_minor = ROC_AE_MINOR_OP_PKCS_DEC;
301 /* Public key decrypt, use BT1 */
302 w4.s.param2 = ROC_AE_CPT_BLOCK_TYPE1;
306 w4.s.opcode_major = ROC_AE_MAJOR_OP_MODEX;
308 w4.s.param1 = mod_len;
311 inst->w4.u64 = w4.u64;
312 inst->rptr = (uintptr_t)dptr;
315 static __rte_always_inline void
316 cnxk_ae_rsa_crt_prep(struct rte_crypto_op *op, struct roc_ae_buf_ptr *meta_buf,
317 struct rte_crypto_rsa_xform *rsa,
318 rte_crypto_param *crypto_param, struct cpt_inst_s *inst)
320 uint32_t qInv_len = rsa->qt.qInv.length;
321 struct rte_crypto_rsa_op_param rsa_op;
322 uint32_t dP_len = rsa->qt.dP.length;
323 uint32_t dQ_len = rsa->qt.dQ.length;
324 uint32_t p_len = rsa->qt.p.length;
325 uint32_t q_len = rsa->qt.q.length;
326 uint32_t mod_len = rsa->n.length;
327 uint64_t total_key_len;
328 union cpt_inst_w4 w4;
333 rsa_op = op->asym->rsa;
334 total_key_len = p_len + q_len + dP_len + dQ_len + qInv_len;
337 dptr = meta_buf->vaddr;
338 inst->dptr = (uintptr_t)dptr;
339 memcpy(dptr, rsa->qt.q.data, total_key_len);
340 dptr += total_key_len;
342 in_size = crypto_param->length;
343 memcpy(dptr, crypto_param->data, in_size);
346 dlen = total_key_len + in_size;
348 if (rsa_op.pad == RTE_CRYPTO_RSA_PADDING_NONE) {
349 /*Use mod_exp operation for no_padding type */
350 w4.s.opcode_minor = ROC_AE_MINOR_OP_MODEX_CRT;
352 if (rsa_op.op_type == RTE_CRYPTO_ASYM_OP_SIGN) {
353 w4.s.opcode_minor = ROC_AE_MINOR_OP_PKCS_ENC_CRT;
354 /* Private encrypt, use BT1 */
355 w4.s.param2 = ROC_AE_CPT_BLOCK_TYPE1;
356 } else if (rsa_op.op_type == RTE_CRYPTO_ASYM_OP_DECRYPT) {
357 w4.s.opcode_minor = ROC_AE_MINOR_OP_PKCS_DEC_CRT;
358 /* Private decrypt, use BT2 */
359 w4.s.param2 = ROC_AE_CPT_BLOCK_TYPE2;
363 w4.s.opcode_major = ROC_AE_MAJOR_OP_MODEX;
365 w4.s.param1 = mod_len;
368 inst->w4.u64 = w4.u64;
369 inst->rptr = (uintptr_t)dptr;
372 static __rte_always_inline int __rte_hot
373 cnxk_ae_enqueue_rsa_op(struct rte_crypto_op *op,
374 struct roc_ae_buf_ptr *meta_buf,
375 struct cnxk_ae_sess *sess, struct cpt_inst_s *inst)
377 struct rte_crypto_rsa_op_param *rsa = &op->asym->rsa;
379 switch (rsa->op_type) {
380 case RTE_CRYPTO_ASYM_OP_VERIFY:
381 cnxk_ae_rsa_prep(op, meta_buf, &sess->rsa_ctx, &rsa->sign,
384 case RTE_CRYPTO_ASYM_OP_ENCRYPT:
385 cnxk_ae_rsa_prep(op, meta_buf, &sess->rsa_ctx, &rsa->message,
388 case RTE_CRYPTO_ASYM_OP_SIGN:
389 cnxk_ae_rsa_crt_prep(op, meta_buf, &sess->rsa_ctx,
390 &rsa->message, inst);
392 case RTE_CRYPTO_ASYM_OP_DECRYPT:
393 cnxk_ae_rsa_crt_prep(op, meta_buf, &sess->rsa_ctx, &rsa->cipher,
397 op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
403 static __rte_always_inline void
404 cnxk_ae_ecdsa_sign_prep(struct rte_crypto_ecdsa_op_param *ecdsa,
405 struct roc_ae_buf_ptr *meta_buf,
406 uint64_t fpm_table_iova, struct roc_ae_ec_group *ec_grp,
407 uint8_t curveid, struct cpt_inst_s *inst)
409 uint16_t message_len = ecdsa->message.length;
410 uint16_t pkey_len = ecdsa->pkey.length;
411 uint16_t p_align, k_align, m_align;
412 uint16_t k_len = ecdsa->k.length;
413 uint16_t order_len, prime_len;
414 uint16_t o_offset, pk_offset;
415 union cpt_inst_w4 w4;
419 prime_len = ec_grp->prime.length;
420 order_len = ec_grp->order.length;
422 /* Truncate input length to curve prime length */
423 if (message_len > prime_len)
424 message_len = prime_len;
425 m_align = RTE_ALIGN_CEIL(message_len, 8);
427 p_align = RTE_ALIGN_CEIL(prime_len, 8);
428 k_align = RTE_ALIGN_CEIL(k_len, 8);
430 /* Set write offset for order and private key */
431 o_offset = prime_len - order_len;
432 pk_offset = prime_len - pkey_len;
435 dptr = meta_buf->vaddr;
436 inst->dptr = (uintptr_t)dptr;
439 * Set dlen = sum(sizeof(fpm address), ROUNDUP8(scalar len, input len),
440 * ROUNDUP8(priv key len, prime len, order len)).
441 * Please note, private key, order cannot exceed prime
442 * length i.e 3 * p_align.
444 dlen = sizeof(fpm_table_iova) + k_align + m_align + p_align * 5;
446 memset(dptr, 0, dlen);
448 *(uint64_t *)dptr = fpm_table_iova;
449 dptr += sizeof(fpm_table_iova);
451 memcpy(dptr, ecdsa->k.data, k_len);
454 memcpy(dptr, ec_grp->prime.data, prime_len);
457 memcpy(dptr + o_offset, ec_grp->order.data, order_len);
460 memcpy(dptr + pk_offset, ecdsa->pkey.data, pkey_len);
463 memcpy(dptr, ecdsa->message.data, message_len);
466 memcpy(dptr, ec_grp->consta.data, prime_len);
469 memcpy(dptr, ec_grp->constb.data, prime_len);
473 w4.s.opcode_major = ROC_AE_MAJOR_OP_ECDSA;
474 w4.s.opcode_minor = ROC_AE_MINOR_OP_ECDSA_SIGN;
476 w4.s.param1 = curveid | (message_len << 8);
477 w4.s.param2 = (pkey_len << 8) | k_len;
480 inst->w4.u64 = w4.u64;
481 inst->rptr = (uintptr_t)dptr;
484 static __rte_always_inline void
485 cnxk_ae_ecdsa_verify_prep(struct rte_crypto_ecdsa_op_param *ecdsa,
486 struct roc_ae_buf_ptr *meta_buf,
487 uint64_t fpm_table_iova,
488 struct roc_ae_ec_group *ec_grp, uint8_t curveid,
489 struct cpt_inst_s *inst)
491 uint32_t message_len = ecdsa->message.length;
492 uint16_t o_offset, r_offset, s_offset;
493 uint16_t qx_len = ecdsa->q.x.length;
494 uint16_t qy_len = ecdsa->q.y.length;
495 uint16_t r_len = ecdsa->r.length;
496 uint16_t s_len = ecdsa->s.length;
497 uint16_t order_len, prime_len;
498 uint16_t qx_offset, qy_offset;
499 uint16_t p_align, m_align;
500 union cpt_inst_w4 w4;
504 prime_len = ec_grp->prime.length;
505 order_len = ec_grp->order.length;
507 /* Truncate input length to curve prime length */
508 if (message_len > prime_len)
509 message_len = prime_len;
511 m_align = RTE_ALIGN_CEIL(message_len, 8);
512 p_align = RTE_ALIGN_CEIL(prime_len, 8);
514 /* Set write offset for sign, order and public key coordinates */
515 o_offset = prime_len - order_len;
516 qx_offset = prime_len - qx_len;
517 qy_offset = prime_len - qy_len;
518 r_offset = prime_len - r_len;
519 s_offset = prime_len - s_len;
522 dptr = meta_buf->vaddr;
523 inst->dptr = (uintptr_t)dptr;
526 * Set dlen = sum(sizeof(fpm address), ROUNDUP8(message len),
527 * ROUNDUP8(sign len(r and s), public key len(x and y coordinates),
528 * prime len, order len)).
529 * Please note sign, public key and order can not exceed prime length
532 dlen = sizeof(fpm_table_iova) + m_align + (8 * p_align);
534 memset(dptr, 0, dlen);
536 *(uint64_t *)dptr = fpm_table_iova;
537 dptr += sizeof(fpm_table_iova);
539 memcpy(dptr + r_offset, ecdsa->r.data, r_len);
542 memcpy(dptr + s_offset, ecdsa->s.data, s_len);
545 memcpy(dptr, ecdsa->message.data, message_len);
548 memcpy(dptr + o_offset, ec_grp->order.data, order_len);
551 memcpy(dptr, ec_grp->prime.data, prime_len);
554 memcpy(dptr + qx_offset, ecdsa->q.x.data, qx_len);
557 memcpy(dptr + qy_offset, ecdsa->q.y.data, qy_len);
560 memcpy(dptr, ec_grp->consta.data, prime_len);
563 memcpy(dptr, ec_grp->constb.data, prime_len);
567 w4.s.opcode_major = ROC_AE_MAJOR_OP_ECDSA;
568 w4.s.opcode_minor = ROC_AE_MINOR_OP_ECDSA_VERIFY;
570 w4.s.param1 = curveid | (message_len << 8);
574 inst->w4.u64 = w4.u64;
575 inst->rptr = (uintptr_t)dptr;
578 static __rte_always_inline int __rte_hot
579 cnxk_ae_enqueue_ecdsa_op(struct rte_crypto_op *op,
580 struct roc_ae_buf_ptr *meta_buf,
581 struct cnxk_ae_sess *sess, uint64_t *fpm_iova,
582 struct roc_ae_ec_group **ec_grp,
583 struct cpt_inst_s *inst)
585 struct rte_crypto_ecdsa_op_param *ecdsa = &op->asym->ecdsa;
586 uint8_t curveid = sess->ec_ctx.curveid;
588 if (ecdsa->op_type == RTE_CRYPTO_ASYM_OP_SIGN)
589 cnxk_ae_ecdsa_sign_prep(ecdsa, meta_buf, fpm_iova[curveid],
590 ec_grp[curveid], curveid, inst);
591 else if (ecdsa->op_type == RTE_CRYPTO_ASYM_OP_VERIFY)
592 cnxk_ae_ecdsa_verify_prep(ecdsa, meta_buf, fpm_iova[curveid],
593 ec_grp[curveid], curveid, inst);
595 op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
601 static __rte_always_inline int
602 cnxk_ae_ecpm_prep(struct rte_crypto_ecpm_op_param *ecpm,
603 struct roc_ae_buf_ptr *meta_buf,
604 struct roc_ae_ec_group *ec_grp, uint8_t curveid,
605 struct cpt_inst_s *inst)
607 uint16_t x1_len = ecpm->p.x.length;
608 uint16_t y1_len = ecpm->p.y.length;
609 uint16_t scalar_align, p_align;
610 uint16_t x1_offset, y1_offset;
611 uint16_t dlen, prime_len;
612 union cpt_inst_w4 w4;
615 prime_len = ec_grp->prime.length;
618 dptr = meta_buf->vaddr;
619 inst->dptr = (uintptr_t)dptr;
621 p_align = RTE_ALIGN_CEIL(prime_len, 8);
622 scalar_align = RTE_ALIGN_CEIL(ecpm->scalar.length, 8);
625 * Set dlen = sum(ROUNDUP8(input point(x and y coordinates), prime,
627 * Please note point length is equivalent to prime of the curve
629 dlen = 5 * p_align + scalar_align;
631 x1_offset = prime_len - x1_len;
632 y1_offset = prime_len - y1_len;
634 memset(dptr, 0, dlen);
636 /* Copy input point, scalar, prime */
637 memcpy(dptr + x1_offset, ecpm->p.x.data, x1_len);
639 memcpy(dptr + y1_offset, ecpm->p.y.data, y1_len);
641 memcpy(dptr, ecpm->scalar.data, ecpm->scalar.length);
642 dptr += scalar_align;
643 memcpy(dptr, ec_grp->prime.data, ec_grp->prime.length);
645 memcpy(dptr, ec_grp->consta.data, ec_grp->consta.length);
647 memcpy(dptr, ec_grp->constb.data, ec_grp->constb.length);
651 w4.s.opcode_major = ROC_AE_MAJOR_OP_ECC;
652 w4.s.opcode_minor = ROC_AE_MINOR_OP_ECC_UMP;
654 w4.s.param1 = curveid;
655 w4.s.param2 = ecpm->scalar.length;
658 inst->w4.u64 = w4.u64;
659 inst->rptr = (uintptr_t)dptr;
664 static __rte_always_inline void
665 cnxk_ae_dequeue_rsa_op(struct rte_crypto_op *cop, uint8_t *rptr,
666 struct rte_crypto_rsa_xform *rsa_ctx)
668 struct rte_crypto_rsa_op_param *rsa = &cop->asym->rsa;
670 switch (rsa->op_type) {
671 case RTE_CRYPTO_ASYM_OP_ENCRYPT:
672 rsa->cipher.length = rsa_ctx->n.length;
673 memcpy(rsa->cipher.data, rptr, rsa->cipher.length);
675 case RTE_CRYPTO_ASYM_OP_DECRYPT:
676 if (rsa->pad == RTE_CRYPTO_RSA_PADDING_NONE) {
677 rsa->message.length = rsa_ctx->n.length;
678 memcpy(rsa->message.data, rptr, rsa->message.length);
680 /* Get length of decrypted output */
681 rsa->message.length =
682 rte_cpu_to_be_16(*((uint16_t *)rptr));
684 * Offset output data pointer by length field
685 * (2 bytes) and copy decrypted data.
687 memcpy(rsa->message.data, rptr + 2,
688 rsa->message.length);
691 case RTE_CRYPTO_ASYM_OP_SIGN:
692 rsa->sign.length = rsa_ctx->n.length;
693 memcpy(rsa->sign.data, rptr, rsa->sign.length);
695 case RTE_CRYPTO_ASYM_OP_VERIFY:
696 if (rsa->pad == RTE_CRYPTO_RSA_PADDING_NONE) {
697 rsa->sign.length = rsa_ctx->n.length;
698 memcpy(rsa->sign.data, rptr, rsa->sign.length);
700 /* Get length of signed output */
702 rte_cpu_to_be_16(*((uint16_t *)rptr));
704 * Offset output data pointer by length field
705 * (2 bytes) and copy signed data.
707 memcpy(rsa->sign.data, rptr + 2, rsa->sign.length);
709 if (memcmp(rsa->sign.data, rsa->message.data,
710 rsa->message.length)) {
711 cop->status = RTE_CRYPTO_OP_STATUS_ERROR;
715 cop->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
720 static __rte_always_inline void
721 cnxk_ae_dequeue_ecdsa_op(struct rte_crypto_ecdsa_op_param *ecdsa, uint8_t *rptr,
722 struct roc_ae_ec_ctx *ec,
723 struct roc_ae_ec_group **ec_grp)
725 int prime_len = ec_grp[ec->curveid]->prime.length;
727 if (ecdsa->op_type == RTE_CRYPTO_ASYM_OP_VERIFY)
730 /* Separate out sign r and s components */
731 memcpy(ecdsa->r.data, rptr, prime_len);
732 memcpy(ecdsa->s.data, rptr + RTE_ALIGN_CEIL(prime_len, 8), prime_len);
733 ecdsa->r.length = prime_len;
734 ecdsa->s.length = prime_len;
737 static __rte_always_inline void
738 cnxk_ae_dequeue_ecpm_op(struct rte_crypto_ecpm_op_param *ecpm, uint8_t *rptr,
739 struct roc_ae_ec_ctx *ec,
740 struct roc_ae_ec_group **ec_grp)
742 int prime_len = ec_grp[ec->curveid]->prime.length;
744 memcpy(ecpm->r.x.data, rptr, prime_len);
745 memcpy(ecpm->r.y.data, rptr + RTE_ALIGN_CEIL(prime_len, 8), prime_len);
746 ecpm->r.x.length = prime_len;
747 ecpm->r.y.length = prime_len;
750 static __rte_always_inline void *
751 cnxk_ae_alloc_meta(struct roc_ae_buf_ptr *buf,
752 struct rte_mempool *cpt_meta_pool,
753 struct cpt_inflight_req *infl_req)
757 if (unlikely(rte_mempool_get(cpt_meta_pool, (void **)&mdata) < 0))
762 infl_req->mdata = mdata;
763 infl_req->op_flags |= CPT_OP_FLAGS_METABUF;
768 static __rte_always_inline int32_t __rte_hot
769 cnxk_ae_enqueue(struct cnxk_cpt_qp *qp, struct rte_crypto_op *op,
770 struct cpt_inflight_req *infl_req, struct cpt_inst_s *inst,
771 struct cnxk_ae_sess *sess)
773 struct cpt_qp_meta_info *minfo = &qp->meta_info;
774 struct rte_crypto_asym_op *asym_op = op->asym;
775 struct roc_ae_buf_ptr meta_buf;
780 mdata = cnxk_ae_alloc_meta(&meta_buf, minfo->pool, infl_req);
784 /* Reserve 8B for RPTR */
785 meta_buf.vaddr = PLT_PTR_ADD(mdata, sizeof(uint64_t));
787 switch (sess->xfrm_type) {
788 case RTE_CRYPTO_ASYM_XFORM_MODEX:
789 ret = cnxk_ae_modex_prep(op, &meta_buf, &sess->mod_ctx, inst);
793 case RTE_CRYPTO_ASYM_XFORM_RSA:
794 ret = cnxk_ae_enqueue_rsa_op(op, &meta_buf, sess, inst);
798 case RTE_CRYPTO_ASYM_XFORM_ECDSA:
799 ret = cnxk_ae_enqueue_ecdsa_op(op, &meta_buf, sess,
805 case RTE_CRYPTO_ASYM_XFORM_ECPM:
806 ret = cnxk_ae_ecpm_prep(&asym_op->ecpm, &meta_buf,
807 sess->ec_grp[sess->ec_ctx.curveid],
808 sess->ec_ctx.curveid, inst);
813 op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
823 rte_mempool_put(minfo->pool, infl_req->mdata);
827 static __rte_always_inline void
828 cnxk_ae_post_process(struct rte_crypto_op *cop, struct cnxk_ae_sess *sess,
831 struct rte_crypto_asym_op *op = cop->asym;
833 switch (sess->xfrm_type) {
834 case RTE_CRYPTO_ASYM_XFORM_RSA:
835 cnxk_ae_dequeue_rsa_op(cop, rptr, &sess->rsa_ctx);
837 case RTE_CRYPTO_ASYM_XFORM_MODEX:
838 op->modex.result.length = sess->mod_ctx.modulus.length;
839 memcpy(op->modex.result.data, rptr, op->modex.result.length);
841 case RTE_CRYPTO_ASYM_XFORM_ECDSA:
842 cnxk_ae_dequeue_ecdsa_op(&op->ecdsa, rptr, &sess->ec_ctx,
845 case RTE_CRYPTO_ASYM_XFORM_ECPM:
846 cnxk_ae_dequeue_ecpm_op(&op->ecpm, rptr, &sess->ec_ctx,
850 cop->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
854 #endif /* _CNXK_AE_H_ */