drivers/crypto/qat/qat_asym.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #include <stdarg.h>
   6
   7 #include "qat_asym.h"
   8 #include "icp_qat_fw_pke.h"
   9 #include "icp_qat_fw.h"
  10 #include "qat_pke_functionality_arrays.h"
  11
  12 #define qat_asym_sz_2param(arg) (arg, sizeof(arg)/sizeof(*arg))
  13
  14 static int qat_asym_get_sz_and_func_id(const uint32_t arr[][2],
  15                 size_t arr_sz, size_t *size, uint32_t *func_id)
  16 {
  17         size_t i;
  18
  19         for (i = 0; i < arr_sz; i++) {
  20                 if (*size <= arr[i][0]) {
  21                         *size = arr[i][0];
  22                         *func_id = arr[i][1];
  23                         return 0;
  24                 }
  25         }
  26         return -1;
  27 }
  28
  29 static inline void qat_fill_req_tmpl(struct icp_qat_fw_pke_request *qat_req)
  30 {
  31         memset(qat_req, 0, sizeof(*qat_req));
  32         qat_req->pke_hdr.service_type = ICP_QAT_FW_COMN_REQ_CPM_FW_PKE;
  33
  34         qat_req->pke_hdr.hdr_flags =
  35                         ICP_QAT_FW_COMN_HDR_FLAGS_BUILD
  36                         (ICP_QAT_FW_COMN_REQ_FLAG_SET);
  37 }
  38
  39 static inline void qat_asym_build_req_tmpl(void *sess_private_data)
  40 {
  41         struct icp_qat_fw_pke_request *qat_req;
  42         struct qat_asym_session *session = sess_private_data;
  43
  44         qat_req = &session->req_tmpl;
  45         qat_fill_req_tmpl(qat_req);
  46 }
  47
  48 static size_t max_of(int n, ...)
  49 {
  50         va_list args;
  51         size_t len = 0, num;
  52         int i;
  53
  54         va_start(args, n);
  55         len = va_arg(args, size_t);
  56
  57         for (i = 0; i < n - 1; i++) {
  58                 num = va_arg(args, size_t);
  59                 if (num > len)
  60                         len = num;
  61         }
  62         va_end(args);
  63
  64         return len;
  65 }
  66
  67 static void qat_clear_arrays(struct qat_asym_op_cookie *cookie,
  68                 int in_count, int out_count, int in_size, int out_size)
  69 {
  70         int i;
  71
  72         for (i = 0; i < in_count; i++)
  73                 memset(cookie->input_array[i], 0x0, in_size);
  74         for (i = 0; i < out_count; i++)
  75                 memset(cookie->output_array[i], 0x0, out_size);
  76 }
  77
  78 static void qat_clear_arrays_by_alg(struct qat_asym_op_cookie *cookie,
  79                 enum rte_crypto_asym_xform_type alg, int in_size, int out_size)
  80 {
  81         if (alg == RTE_CRYPTO_ASYM_XFORM_MODEX)
  82                 qat_clear_arrays(cookie, QAT_ASYM_MODEXP_NUM_IN_PARAMS,
  83                                 QAT_ASYM_MODEXP_NUM_OUT_PARAMS, in_size,
  84                                 out_size);
  85         else if (alg == RTE_CRYPTO_ASYM_XFORM_MODINV)
  86                 qat_clear_arrays(cookie, QAT_ASYM_MODINV_NUM_IN_PARAMS,
  87                                 QAT_ASYM_MODINV_NUM_OUT_PARAMS, in_size,
  88                                 out_size);
  89 }
  90
  91 static int qat_asym_check_nonzero(rte_crypto_param n)
  92 {
  93         if (n.length < 8) {
  94                 /* Not a case for any cryptograpic function except for DH
  95                  * generator which very often can be of one byte length
  96                  */
  97                 size_t i;
  98
  99                 if (n.data[n.length - 1] == 0x0) {
 100                         for (i = 0; i < n.length - 1; i++)
 101                                 if (n.data[i] != 0x0)
 102                                         break;
 103                         if (i == n.length - 1)
 104                                 return -(EINVAL);
 105                 }
 106         } else if (*(uint64_t *)&n.data[
 107                                 n.length - 8] == 0) {
 108                 /* Very likely it is zeroed modulus */
 109                 size_t i;
 110
 111                 for (i = 0; i < n.length - 8; i++)
 112                         if (n.data[i] != 0x0)
 113                                 break;
 114                 if (i == n.length - 8)
 115                         return -(EINVAL);
 116         }
 117
 118         return 0;
 119 }
 120
 121 static int
 122 qat_asym_fill_arrays(struct rte_crypto_asym_op *asym_op,
 123                 struct icp_qat_fw_pke_request *qat_req,
 124                 struct qat_asym_op_cookie *cookie,
 125                 struct rte_crypto_asym_xform *xform)
 126 {
 127         int err = 0;
 128         size_t alg_size;
 129         size_t alg_size_in_bytes;
 130         uint32_t func_id = 0;
 131
 132         if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX) {
 133                 err = qat_asym_check_nonzero(xform->modex.modulus);
 134                 if (err) {
 135                         QAT_LOG(ERR, "Empty modulus in modular exponentiation,"
 136                                         " aborting this operation");
 137                         return err;
 138                 }
 139
 140                 alg_size_in_bytes = max_of(3, asym_op->modex.base.length,
 141                                xform->modex.exponent.length,
 142                                xform->modex.modulus.length);
 143                 alg_size = alg_size_in_bytes << 3;
 144
 145                 if (qat_asym_get_sz_and_func_id(MOD_EXP_SIZE,
 146                                 sizeof(MOD_EXP_SIZE)/sizeof(*MOD_EXP_SIZE),
 147                                 &alg_size, &func_id)) {
 148                         return -(EINVAL);
 149                 }
 150
 151                 alg_size_in_bytes = alg_size >> 3;
 152                 rte_memcpy(cookie->input_array[0] + alg_size_in_bytes -
 153                         asym_op->modex.base.length
 154                         , asym_op->modex.base.data,
 155                         asym_op->modex.base.length);
 156                 rte_memcpy(cookie->input_array[1] + alg_size_in_bytes -
 157                         xform->modex.exponent.length
 158                         , xform->modex.exponent.data,
 159                         xform->modex.exponent.length);
 160                 rte_memcpy(cookie->input_array[2]  + alg_size_in_bytes -
 161                         xform->modex.modulus.length,
 162                         xform->modex.modulus.data,
 163                         xform->modex.modulus.length);
 164                 cookie->alg_size = alg_size;
 165                 qat_req->pke_hdr.cd_pars.func_id = func_id;
 166                 qat_req->input_param_count = QAT_ASYM_MODEXP_NUM_IN_PARAMS;
 167                 qat_req->output_param_count = QAT_ASYM_MODEXP_NUM_OUT_PARAMS;
 168 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 169                 QAT_DP_HEXDUMP_LOG(DEBUG, "ModExp base",
 170                                 cookie->input_array[0],
 171                                 alg_size_in_bytes);
 172                 QAT_DP_HEXDUMP_LOG(DEBUG, "ModExp exponent",
 173                                 cookie->input_array[1],
 174                                 alg_size_in_bytes);
 175                 QAT_DP_HEXDUMP_LOG(DEBUG, " ModExpmodulus",
 176                                 cookie->input_array[2],
 177                                 alg_size_in_bytes);
 178 #endif
 179         } else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) {
 180                 err = qat_asym_check_nonzero(xform->modinv.modulus);
 181                 if (err) {
 182                         QAT_LOG(ERR, "Empty modulus in modular multiplicative"
 183                                         " inverse, aborting this operation");
 184                         return err;
 185                 }
 186
 187                 alg_size_in_bytes = max_of(2, asym_op->modinv.base.length,
 188                                 xform->modinv.modulus.length);
 189                 alg_size = alg_size_in_bytes << 3;
 190
 191                 if (xform->modinv.modulus.data[
 192                                 xform->modinv.modulus.length - 1] & 0x01) {
 193                         if (qat_asym_get_sz_and_func_id(MOD_INV_IDS_ODD,
 194                                         sizeof(MOD_INV_IDS_ODD)/
 195                                         sizeof(*MOD_INV_IDS_ODD),
 196                                         &alg_size, &func_id)) {
 197                                 return -(EINVAL);
 198                         }
 199                 } else {
 200                         if (qat_asym_get_sz_and_func_id(MOD_INV_IDS_EVEN,
 201                                         sizeof(MOD_INV_IDS_EVEN)/
 202                                         sizeof(*MOD_INV_IDS_EVEN),
 203                                         &alg_size, &func_id)) {
 204                                 return -(EINVAL);
 205                         }
 206                 }
 207
 208                 alg_size_in_bytes = alg_size >> 3;
 209                 rte_memcpy(cookie->input_array[0] + alg_size_in_bytes -
 210                         asym_op->modinv.base.length
 211                                 , asym_op->modinv.base.data,
 212                                 asym_op->modinv.base.length);
 213                 rte_memcpy(cookie->input_array[1] + alg_size_in_bytes -
 214                                 xform->modinv.modulus.length
 215                                 , xform->modinv.modulus.data,
 216                                 xform->modinv.modulus.length);
 217                 cookie->alg_size = alg_size;
 218                 qat_req->pke_hdr.cd_pars.func_id = func_id;
 219                 qat_req->input_param_count =
 220                                 QAT_ASYM_MODINV_NUM_IN_PARAMS;
 221                 qat_req->output_param_count =
 222                                 QAT_ASYM_MODINV_NUM_OUT_PARAMS;
 223 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 224                 QAT_DP_HEXDUMP_LOG(DEBUG, "ModInv base",
 225                                 cookie->input_array[0],
 226                                 alg_size_in_bytes);
 227                 QAT_DP_HEXDUMP_LOG(DEBUG, "ModInv modulus",
 228                                 cookie->input_array[1],
 229                                 alg_size_in_bytes);
 230 #endif
 231         } else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_RSA) {
 232                 err = qat_asym_check_nonzero(xform->rsa.n);
 233                 if (err) {
 234                         QAT_LOG(ERR, "Empty modulus in RSA"
 235                                         " inverse, aborting this operation");
 236                         return err;
 237                 }
 238
 239                 alg_size_in_bytes = xform->rsa.n.length;
 240                 alg_size = alg_size_in_bytes << 3;
 241
 242                 qat_req->input_param_count =
 243                                 QAT_ASYM_RSA_NUM_IN_PARAMS;
 244                 qat_req->output_param_count =
 245                                 QAT_ASYM_RSA_NUM_OUT_PARAMS;
 246
 247                 if (asym_op->rsa.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT ||
 248                                 asym_op->rsa.op_type ==
 249                                                 RTE_CRYPTO_ASYM_OP_VERIFY) {
 250
 251                         if (qat_asym_get_sz_and_func_id(RSA_ENC_IDS,
 252                                         sizeof(RSA_ENC_IDS)/
 253                                         sizeof(*RSA_ENC_IDS),
 254                                         &alg_size, &func_id)) {
 255                                 err = -(EINVAL);
 256                                 QAT_LOG(ERR,
 257                                         "Not supported RSA parameter size (key)");
 258                                 return err;
 259                         }
 260                         alg_size_in_bytes = alg_size >> 3;
 261                         if (asym_op->rsa.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT) {
 262                                 switch (asym_op->rsa.pad) {
 263                                 case RTE_CRYPTO_RSA_PADDING_NONE:
 264                                         rte_memcpy(cookie->input_array[0] +
 265                                                 alg_size_in_bytes -
 266                                                 asym_op->rsa.message.length
 267                                                 , asym_op->rsa.message.data,
 268                                                 asym_op->rsa.message.length);
 269                                         break;
 270                                 default:
 271                                         err = -(EINVAL);
 272                                         QAT_LOG(ERR,
 273                                                 "Invalid RSA padding (Encryption)");
 274                                         return err;
 275                                 }
 276 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 277                                 QAT_DP_HEXDUMP_LOG(DEBUG, "RSA Message",
 278                                                 cookie->input_array[0],
 279                                                 alg_size_in_bytes);
 280 #endif
 281                         } else {
 282                                 switch (asym_op->rsa.pad) {
 283                                 case RTE_CRYPTO_RSA_PADDING_NONE:
 284                                         rte_memcpy(cookie->input_array[0],
 285                                                 asym_op->rsa.sign.data,
 286                                                 alg_size_in_bytes);
 287                                         break;
 288                                 default:
 289                                         err = -(EINVAL);
 290                                         QAT_LOG(ERR,
 291                                                 "Invalid RSA padding (Verify)");
 292                                         return err;
 293                                 }
 294
 295 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 296                                 QAT_DP_HEXDUMP_LOG(DEBUG, " RSA Signature",
 297                                                 cookie->input_array[0],
 298                                                 alg_size_in_bytes);
 299 #endif
 300
 301                         }
 302                         rte_memcpy(cookie->input_array[1] +
 303                                         alg_size_in_bytes -
 304                                         xform->rsa.e.length
 305                                         , xform->rsa.e.data,
 306                                         xform->rsa.e.length);
 307                         rte_memcpy(cookie->input_array[2] +
 308                                         alg_size_in_bytes -
 309                                         xform->rsa.n.length,
 310                                         xform->rsa.n.data,
 311                                         xform->rsa.n.length);
 312
 313                         cookie->alg_size = alg_size;
 314                         qat_req->pke_hdr.cd_pars.func_id = func_id;
 315
 316 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 317                         QAT_DP_HEXDUMP_LOG(DEBUG, "RSA Public Key",
 318                                         cookie->input_array[1], alg_size_in_bytes);
 319                         QAT_DP_HEXDUMP_LOG(DEBUG, "RSA Modulus",
 320                                         cookie->input_array[2], alg_size_in_bytes);
 321 #endif
 322                 } else {
 323                         if (asym_op->rsa.op_type ==
 324                                         RTE_CRYPTO_ASYM_OP_DECRYPT) {
 325                                 switch (asym_op->rsa.pad) {
 326                                 case RTE_CRYPTO_RSA_PADDING_NONE:
 327                                         rte_memcpy(cookie->input_array[0]
 328                                                 + alg_size_in_bytes -
 329                                                 asym_op->rsa.cipher.length,
 330                                                 asym_op->rsa.cipher.data,
 331                                                 asym_op->rsa.cipher.length);
 332                                         break;
 333                                 default:
 334                                         QAT_LOG(ERR,
 335                                                 "Invalid padding of RSA (Decrypt)");
 336                                         return -(EINVAL);
 337                                 }
 338
 339                         } else if (asym_op->rsa.op_type ==
 340                                         RTE_CRYPTO_ASYM_OP_SIGN) {
 341                                 switch (asym_op->rsa.pad) {
 342                                 case RTE_CRYPTO_RSA_PADDING_NONE:
 343                                         rte_memcpy(cookie->input_array[0]
 344                                                 + alg_size_in_bytes -
 345                                                 asym_op->rsa.message.length,
 346                                                 asym_op->rsa.message.data,
 347                                                 asym_op->rsa.message.length);
 348                                         break;
 349                                 default:
 350                                         QAT_LOG(ERR,
 351                                                 "Invalid padding of RSA (Signature)");
 352                                         return -(EINVAL);
 353                                 }
 354                         }
 355
 356                         if (xform->rsa.key_type == RTE_RSA_KET_TYPE_QT) {
 357                                 QAT_LOG(ERR, "RSA CRT not implemented");
 358                                 return -(EINVAL);
 359                         } else if (xform->rsa.key_type ==
 360                                         RTE_RSA_KEY_TYPE_EXP) {
 361                                 if (qat_asym_get_sz_and_func_id(
 362                                                 RSA_DEC_IDS,
 363                                                 sizeof(RSA_DEC_IDS)/
 364                                                 sizeof(*RSA_DEC_IDS),
 365                                                 &alg_size, &func_id)) {
 366                                         return -(EINVAL);
 367                                 }
 368                                 alg_size_in_bytes = alg_size >> 3;
 369                                 rte_memcpy(cookie->input_array[1] +
 370                                                 alg_size_in_bytes -
 371                                                 xform->rsa.d.length,
 372                                                 xform->rsa.d.data,
 373                                                 xform->rsa.d.length);
 374                                 rte_memcpy(cookie->input_array[2] +
 375                                                 alg_size_in_bytes -
 376                                                 xform->rsa.n.length,
 377                                                 xform->rsa.n.data,
 378                                                 xform->rsa.n.length);
 379 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 380                         QAT_DP_HEXDUMP_LOG(DEBUG, "RSA ciphertext",
 381                                         cookie->input_array[0],
 382                                         alg_size_in_bytes);
 383                         QAT_DP_HEXDUMP_LOG(DEBUG, "RSA d", cookie->input_array[1],
 384                                         alg_size_in_bytes);
 385                         QAT_DP_HEXDUMP_LOG(DEBUG, "RSA n", cookie->input_array[2],
 386                                         alg_size_in_bytes);
 387 #endif
 388
 389                                 cookie->alg_size = alg_size;
 390                                 qat_req->pke_hdr.cd_pars.func_id = func_id;
 391                         } else {
 392                                 QAT_LOG(ERR, "Invalid RSA key type");
 393                                 return -(EINVAL);
 394                         }
 395                 }
 396         } else {
 397                 QAT_LOG(ERR, "Invalid asymmetric crypto xform");
 398                 return -(EINVAL);
 399         }
 400         return 0;
 401 }
 402
 403 int
 404 qat_asym_build_request(void *in_op,
 405                         uint8_t *out_msg,
 406                         void *op_cookie,
 407                         __rte_unused enum qat_device_gen qat_dev_gen)
 408 {
 409         struct qat_asym_session *ctx;
 410         struct rte_crypto_op *op = (struct rte_crypto_op *)in_op;
 411         struct rte_crypto_asym_op *asym_op = op->asym;
 412         struct icp_qat_fw_pke_request *qat_req =
 413                         (struct icp_qat_fw_pke_request *)out_msg;
 414         struct qat_asym_op_cookie *cookie =
 415                                 (struct qat_asym_op_cookie *)op_cookie;
 416         int err = 0;
 417
 418         op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 419         if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
 420                 ctx = (struct qat_asym_session *)
 421                         get_asym_session_private_data(
 422                         op->asym->session, cryptodev_qat_asym_driver_id);
 423                 if (unlikely(ctx == NULL)) {
 424                         QAT_LOG(ERR, "Session has not been created for this device");
 425                         goto error;
 426                 }
 427                 rte_mov64((uint8_t *)qat_req, (const uint8_t *)&(ctx->req_tmpl));
 428                 err = qat_asym_fill_arrays(asym_op, qat_req, cookie, ctx->xform);
 429                 if (err) {
 430                         op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 431                         goto error;
 432                 }
 433         } else if (op->sess_type == RTE_CRYPTO_OP_SESSIONLESS) {
 434                 qat_fill_req_tmpl(qat_req);
 435                 err = qat_asym_fill_arrays(asym_op, qat_req, cookie,
 436                                 op->asym->xform);
 437                 if (err) {
 438                         op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
 439                         goto error;
 440                 }
 441         } else {
 442                 QAT_DP_LOG(ERR, "Invalid session/xform settings");
 443                 op->status = RTE_CRYPTO_OP_STATUS_INVALID_SESSION;
 444                 goto error;
 445         }
 446
 447         qat_req->pke_mid.opaque = (uint64_t)(uintptr_t)op;
 448         qat_req->pke_mid.src_data_addr = cookie->input_addr;
 449         qat_req->pke_mid.dest_data_addr = cookie->output_addr;
 450
 451 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 452         QAT_DP_HEXDUMP_LOG(DEBUG, "qat_req:", qat_req,
 453                         sizeof(struct icp_qat_fw_pke_request));
 454 #endif
 455
 456         return 0;
 457 error:
 458
 459         qat_req->pke_mid.opaque = (uint64_t)(uintptr_t)op;
 460
 461 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 462         QAT_DP_HEXDUMP_LOG(DEBUG, "qat_req:", qat_req,
 463                 sizeof(struct icp_qat_fw_pke_request));
 464 #endif
 465
 466         qat_req->output_param_count = 0;
 467         qat_req->input_param_count = 0;
 468         qat_req->pke_hdr.service_type = ICP_QAT_FW_COMN_REQ_NULL;
 469         cookie->error |= err;
 470
 471         return 0;
 472 }
 473
 474 static void qat_asym_collect_response(struct rte_crypto_op *rx_op,
 475                 struct qat_asym_op_cookie *cookie,
 476                 struct rte_crypto_asym_xform *xform)
 477 {
 478         size_t alg_size, alg_size_in_bytes = 0;
 479         struct rte_crypto_asym_op *asym_op = rx_op->asym;
 480
 481         if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX) {
 482                 rte_crypto_param n = xform->modex.modulus;
 483
 484                 alg_size = cookie->alg_size;
 485                 alg_size_in_bytes = alg_size >> 3;
 486                 uint8_t *modexp_result = asym_op->modex.result.data;
 487
 488                 if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED) {
 489                         rte_memcpy(modexp_result +
 490                                 (asym_op->modex.result.length -
 491                                         n.length),
 492                                 cookie->output_array[0] + alg_size_in_bytes
 493                                 - n.length, n.length
 494                                 );
 495                         rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 496 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 497                         QAT_DP_HEXDUMP_LOG(DEBUG, "ModExp result",
 498                                         cookie->output_array[0],
 499                                         alg_size_in_bytes);
 500
 501 #endif
 502                 }
 503         } else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) {
 504                 rte_crypto_param n = xform->modinv.modulus;
 505
 506                 alg_size = cookie->alg_size;
 507                 alg_size_in_bytes = alg_size >> 3;
 508                 uint8_t *modinv_result = asym_op->modinv.result.data;
 509
 510                 if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED) {
 511                         rte_memcpy(modinv_result + (asym_op->modinv.result.length
 512                                 - n.length),
 513                                 cookie->output_array[0] + alg_size_in_bytes
 514                                 - n.length, n.length);
 515                         rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 516 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 517                         QAT_DP_HEXDUMP_LOG(DEBUG, "ModInv result",
 518                                         cookie->output_array[0],
 519                                         alg_size_in_bytes);
 520 #endif
 521                 }
 522         } else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_RSA) {
 523
 524                 alg_size = cookie->alg_size;
 525                 alg_size_in_bytes = alg_size >> 3;
 526                 if (asym_op->rsa.op_type == RTE_CRYPTO_ASYM_OP_ENCRYPT ||
 527                                 asym_op->rsa.op_type ==
 528                                         RTE_CRYPTO_ASYM_OP_VERIFY) {
 529                         if (asym_op->rsa.op_type ==
 530                                         RTE_CRYPTO_ASYM_OP_ENCRYPT) {
 531                                 uint8_t *rsa_result = asym_op->rsa.cipher.data;
 532
 533                                 rte_memcpy(rsa_result,
 534                                                 cookie->output_array[0],
 535                                                 alg_size_in_bytes);
 536                                 rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 537 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 538                                 QAT_DP_HEXDUMP_LOG(DEBUG, "RSA Encrypted data",
 539                                                 cookie->output_array[0],
 540                                                 alg_size_in_bytes);
 541 #endif
 542                         } else if (asym_op->rsa.op_type ==
 543                                         RTE_CRYPTO_ASYM_OP_VERIFY) {
 544                                 uint8_t *rsa_result = asym_op->rsa.cipher.data;
 545
 546                                 switch (asym_op->rsa.pad) {
 547                                 case RTE_CRYPTO_RSA_PADDING_NONE:
 548                                         rte_memcpy(rsa_result,
 549                                                         cookie->output_array[0],
 550                                                         alg_size_in_bytes);
 551                                         rx_op->status =
 552                                                 RTE_CRYPTO_OP_STATUS_SUCCESS;
 553 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 554                                 QAT_DP_HEXDUMP_LOG(DEBUG, "RSA Signature",
 555                                                 cookie->output_array[0],
 556                                                 alg_size_in_bytes);
 557 #endif
 558                                         break;
 559                                 default:
 560                                         QAT_LOG(ERR, "Padding not supported");
 561                                         rx_op->status =
 562                                                 RTE_CRYPTO_OP_STATUS_ERROR;
 563                                         break;
 564                                 }
 565                         }
 566                 } else {
 567                         if (asym_op->rsa.op_type ==
 568                                         RTE_CRYPTO_ASYM_OP_DECRYPT) {
 569                                 uint8_t *rsa_result = asym_op->rsa.message.data;
 570
 571                                 switch (asym_op->rsa.pad) {
 572                                 case RTE_CRYPTO_RSA_PADDING_NONE:
 573                                         rte_memcpy(rsa_result,
 574                                                 cookie->output_array[0],
 575                                                 alg_size_in_bytes);
 576                                         break;
 577                                 default:
 578                                         QAT_LOG(ERR, "Padding not supported");
 579                                         rx_op->status =
 580                                                 RTE_CRYPTO_OP_STATUS_ERROR;
 581                                         break;
 582                                 }
 583 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 584                                 QAT_DP_HEXDUMP_LOG(DEBUG, "RSA Decrypted Message",
 585                                                 rsa_result, alg_size_in_bytes);
 586 #endif
 587                         } else if (asym_op->rsa.op_type == RTE_CRYPTO_ASYM_OP_SIGN) {
 588                                 uint8_t *rsa_result = asym_op->rsa.sign.data;
 589
 590                                 rte_memcpy(rsa_result,
 591                                                 cookie->output_array[0],
 592                                                 alg_size_in_bytes);
 593                                 rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 594 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 595                                 QAT_DP_HEXDUMP_LOG(DEBUG, "RSA Signature",
 596                                                 cookie->output_array[0],
 597                                                 alg_size_in_bytes);
 598 #endif
 599                         }
 600                 }
 601         }
 602         qat_clear_arrays_by_alg(cookie, xform->xform_type, alg_size_in_bytes,
 603                         alg_size_in_bytes);
 604 }
 605
 606 void
 607 qat_asym_process_response(void **op, uint8_t *resp,
 608                 void *op_cookie)
 609 {
 610         struct qat_asym_session *ctx;
 611         struct icp_qat_fw_pke_resp *resp_msg =
 612                         (struct icp_qat_fw_pke_resp *)resp;
 613         struct rte_crypto_op *rx_op = (struct rte_crypto_op *)(uintptr_t)
 614                         (resp_msg->opaque);
 615         struct qat_asym_op_cookie *cookie = op_cookie;
 616
 617         if (cookie->error) {
 618                 cookie->error = 0;
 619                 if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED)
 620                         rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 621                 QAT_DP_LOG(ERR, "Cookie status returned error");
 622         } else {
 623                 if (ICP_QAT_FW_PKE_RESP_PKE_STAT_GET(
 624                         resp_msg->pke_resp_hdr.resp_status.pke_resp_flags)) {
 625                         if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED)
 626                                 rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 627                         QAT_DP_LOG(ERR, "Asymmetric response status"
 628                                         " returned error");
 629                 }
 630                 if (resp_msg->pke_resp_hdr.resp_status.comn_err_code) {
 631                         if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED)
 632                                 rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 633                         QAT_DP_LOG(ERR, "Asymmetric common status"
 634                                         " returned error");
 635                 }
 636         }
 637
 638         if (rx_op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
 639                 ctx = (struct qat_asym_session *)get_asym_session_private_data(
 640                         rx_op->asym->session, cryptodev_qat_asym_driver_id);
 641                 qat_asym_collect_response(rx_op, cookie, ctx->xform);
 642         } else if (rx_op->sess_type == RTE_CRYPTO_OP_SESSIONLESS) {
 643                 qat_asym_collect_response(rx_op, cookie, rx_op->asym->xform);
 644         }
 645         *op = rx_op;
 646
 647 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 648         QAT_DP_HEXDUMP_LOG(DEBUG, "resp_msg:", resp_msg,
 649                         sizeof(struct icp_qat_fw_pke_resp));
 650 #endif
 651 }
 652
 653 int
 654 qat_asym_session_configure(struct rte_cryptodev *dev,
 655                 struct rte_crypto_asym_xform *xform,
 656                 struct rte_cryptodev_asym_session *sess,
 657                 struct rte_mempool *mempool)
 658 {
 659         int err = 0;
 660         void *sess_private_data;
 661         struct qat_asym_session *session;
 662
 663         if (rte_mempool_get(mempool, &sess_private_data)) {
 664                 QAT_LOG(ERR,
 665                         "Couldn't get object from session mempool");
 666                 return -ENOMEM;
 667         }
 668
 669         session = sess_private_data;
 670         if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX) {
 671                 if (xform->modex.exponent.length == 0 ||
 672                                 xform->modex.modulus.length == 0) {
 673                         QAT_LOG(ERR, "Invalid mod exp input parameter");
 674                         err = -EINVAL;
 675                         goto error;
 676                 }
 677         } else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) {
 678                 if (xform->modinv.modulus.length == 0) {
 679                         QAT_LOG(ERR, "Invalid mod inv input parameter");
 680                         err = -EINVAL;
 681                         goto error;
 682                 }
 683         } else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_RSA) {
 684                 if (xform->rsa.n.length == 0) {
 685                         QAT_LOG(ERR, "Invalid rsa input parameter");
 686                         err = -EINVAL;
 687                         goto error;
 688                 }
 689         } else if (xform->xform_type >= RTE_CRYPTO_ASYM_XFORM_TYPE_LIST_END
 690                         || xform->xform_type <= RTE_CRYPTO_ASYM_XFORM_NONE) {
 691                 QAT_LOG(ERR, "Invalid asymmetric crypto xform");
 692                 err = -EINVAL;
 693                 goto error;
 694         } else {
 695                 QAT_LOG(ERR, "Asymmetric crypto xform not implemented");
 696                 err = -EINVAL;
 697                 goto error;
 698         }
 699
 700         session->xform = xform;
 701         qat_asym_build_req_tmpl(sess_private_data);
 702         set_asym_session_private_data(sess, dev->driver_id,
 703                 sess_private_data);
 704
 705         return 0;
 706 error:
 707         rte_mempool_put(mempool, sess_private_data);
 708         return err;
 709 }
 710
 711 unsigned int qat_asym_session_get_private_size(
 712                 struct rte_cryptodev *dev __rte_unused)
 713 {
 714         return RTE_ALIGN_CEIL(sizeof(struct qat_asym_session), 8);
 715 }
 716
 717 void
 718 qat_asym_session_clear(struct rte_cryptodev *dev,
 719                 struct rte_cryptodev_asym_session *sess)
 720 {
 721         uint8_t index = dev->driver_id;
 722         void *sess_priv = get_asym_session_private_data(sess, index);
 723         struct qat_asym_session *s = (struct qat_asym_session *)sess_priv;
 724
 725         if (sess_priv) {
 726                 memset(s, 0, qat_asym_session_get_private_size(dev));
 727                 struct rte_mempool *sess_mp = rte_mempool_from_obj(sess_priv);
 728
 729                 set_asym_session_private_data(sess, index, NULL);
 730                 rte_mempool_put(sess_mp, sess_priv);
 731         }
 732 }