drivers/crypto/virtio/virtio_crypto_akcipher_algs.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2  /* Asymmetric algorithms supported by virtio crypto device
   3   *
   4   * Authors: zhenwei pi <pizhenwei@bytedance.com>
   5   *          lei he <helei.sig11@bytedance.com>
   6   *
   7   * Copyright 2022 Bytedance CO., LTD.
   8   */
   9
  10 #include <crypto/engine.h>
  11 #include <crypto/internal/akcipher.h>
  12 #include <crypto/internal/rsa.h>
  13 #include <crypto/scatterwalk.h>
  14 #include <linux/err.h>
  15 #include <linux/kernel.h>
  16 #include <linux/mpi.h>
  17 #include <linux/scatterlist.h>
  18 #include <linux/slab.h>
  19 #include <linux/string.h>
  20 #include <uapi/linux/virtio_crypto.h>
  21 #include "virtio_crypto_common.h"
  22
  23 struct virtio_crypto_rsa_ctx {
  24         MPI n;
  25 };
  26
  27 struct virtio_crypto_akcipher_ctx {
  28         struct virtio_crypto *vcrypto;
  29         struct crypto_akcipher *tfm;
  30         bool session_valid;
  31         __u64 session_id;
  32         union {
  33                 struct virtio_crypto_rsa_ctx rsa_ctx;
  34         };
  35 };
  36
  37 struct virtio_crypto_akcipher_request {
  38         struct virtio_crypto_request base;
  39         struct virtio_crypto_akcipher_ctx *akcipher_ctx;
  40         struct akcipher_request *akcipher_req;
  41         void *src_buf;
  42         void *dst_buf;
  43         uint32_t opcode;
  44 };
  45
  46 struct virtio_crypto_akcipher_algo {
  47         uint32_t algonum;
  48         uint32_t service;
  49         unsigned int active_devs;
  50         struct akcipher_engine_alg algo;
  51 };
  52
  53 static DEFINE_MUTEX(algs_lock);
  54
  55 static void virtio_crypto_akcipher_finalize_req(
  56         struct virtio_crypto_akcipher_request *vc_akcipher_req,
  57         struct akcipher_request *req, int err)
  58 {
  59         kfree(vc_akcipher_req->src_buf);
  60         kfree(vc_akcipher_req->dst_buf);
  61         vc_akcipher_req->src_buf = NULL;
  62         vc_akcipher_req->dst_buf = NULL;
  63         virtcrypto_clear_request(&vc_akcipher_req->base);
  64
  65         crypto_finalize_akcipher_request(vc_akcipher_req->base.dataq->engine, req, err);
  66 }
  67
  68 static void virtio_crypto_dataq_akcipher_callback(struct virtio_crypto_request *vc_req, int len)
  69 {
  70         struct virtio_crypto_akcipher_request *vc_akcipher_req =
  71                 container_of(vc_req, struct virtio_crypto_akcipher_request, base);
  72         struct akcipher_request *akcipher_req;
  73         int error;
  74
  75         switch (vc_req->status) {
  76         case VIRTIO_CRYPTO_OK:
  77                 error = 0;
  78                 break;
  79         case VIRTIO_CRYPTO_INVSESS:
  80         case VIRTIO_CRYPTO_ERR:
  81                 error = -EINVAL;
  82                 break;
  83         case VIRTIO_CRYPTO_BADMSG:
  84                 error = -EBADMSG;
  85                 break;
  86
  87         case VIRTIO_CRYPTO_KEY_REJECTED:
  88                 error = -EKEYREJECTED;
  89                 break;
  90
  91         default:
  92                 error = -EIO;
  93                 break;
  94         }
  95
  96         akcipher_req = vc_akcipher_req->akcipher_req;
  97         if (vc_akcipher_req->opcode != VIRTIO_CRYPTO_AKCIPHER_VERIFY) {
  98                 /* actuall length maybe less than dst buffer */
  99                 akcipher_req->dst_len = len - sizeof(vc_req->status);
 100                 sg_copy_from_buffer(akcipher_req->dst, sg_nents(akcipher_req->dst),
 101                                     vc_akcipher_req->dst_buf, akcipher_req->dst_len);
 102         }
 103         virtio_crypto_akcipher_finalize_req(vc_akcipher_req, akcipher_req, error);
 104 }
 105
 106 static int virtio_crypto_alg_akcipher_init_session(struct virtio_crypto_akcipher_ctx *ctx,
 107                 struct virtio_crypto_ctrl_header *header, void *para,
 108                 const uint8_t *key, unsigned int keylen)
 109 {
 110         struct scatterlist outhdr_sg, key_sg, inhdr_sg, *sgs[3];
 111         struct virtio_crypto *vcrypto = ctx->vcrypto;
 112         uint8_t *pkey;
 113         int err;
 114         unsigned int num_out = 0, num_in = 0;
 115         struct virtio_crypto_op_ctrl_req *ctrl;
 116         struct virtio_crypto_session_input *input;
 117         struct virtio_crypto_ctrl_request *vc_ctrl_req;
 118
 119         pkey = kmemdup(key, keylen, GFP_KERNEL);
 120         if (!pkey)
 121                 return -ENOMEM;
 122
 123         vc_ctrl_req = kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL);
 124         if (!vc_ctrl_req) {
 125                 err = -ENOMEM;
 126                 goto out;
 127         }
 128
 129         ctrl = &vc_ctrl_req->ctrl;
 130         memcpy(&ctrl->header, header, sizeof(ctrl->header));
 131         memcpy(&ctrl->u, para, sizeof(ctrl->u));
 132         input = &vc_ctrl_req->input;
 133         input->status = cpu_to_le32(VIRTIO_CRYPTO_ERR);
 134
 135         sg_init_one(&outhdr_sg, ctrl, sizeof(*ctrl));
 136         sgs[num_out++] = &outhdr_sg;
 137
 138         sg_init_one(&key_sg, pkey, keylen);
 139         sgs[num_out++] = &key_sg;
 140
 141         sg_init_one(&inhdr_sg, input, sizeof(*input));
 142         sgs[num_out + num_in++] = &inhdr_sg;
 143
 144         err = virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, num_in, vc_ctrl_req);
 145         if (err < 0)
 146                 goto out;
 147
 148         if (le32_to_cpu(input->status) != VIRTIO_CRYPTO_OK) {
 149                 pr_err("virtio_crypto: Create session failed status: %u\n",
 150                         le32_to_cpu(input->status));
 151                 err = -EINVAL;
 152                 goto out;
 153         }
 154
 155         ctx->session_id = le64_to_cpu(input->session_id);
 156         ctx->session_valid = true;
 157         err = 0;
 158
 159 out:
 160         kfree(vc_ctrl_req);
 161         kfree_sensitive(pkey);
 162
 163         return err;
 164 }
 165
 166 static int virtio_crypto_alg_akcipher_close_session(struct virtio_crypto_akcipher_ctx *ctx)
 167 {
 168         struct scatterlist outhdr_sg, inhdr_sg, *sgs[2];
 169         struct virtio_crypto_destroy_session_req *destroy_session;
 170         struct virtio_crypto *vcrypto = ctx->vcrypto;
 171         unsigned int num_out = 0, num_in = 0;
 172         int err;
 173         struct virtio_crypto_op_ctrl_req *ctrl;
 174         struct virtio_crypto_inhdr *ctrl_status;
 175         struct virtio_crypto_ctrl_request *vc_ctrl_req;
 176
 177         if (!ctx->session_valid)
 178                 return 0;
 179
 180         vc_ctrl_req = kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL);
 181         if (!vc_ctrl_req)
 182                 return -ENOMEM;
 183
 184         ctrl_status = &vc_ctrl_req->ctrl_status;
 185         ctrl_status->status = VIRTIO_CRYPTO_ERR;
 186         ctrl = &vc_ctrl_req->ctrl;
 187         ctrl->header.opcode = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION);
 188         ctrl->header.queue_id = 0;
 189
 190         destroy_session = &ctrl->u.destroy_session;
 191         destroy_session->session_id = cpu_to_le64(ctx->session_id);
 192
 193         sg_init_one(&outhdr_sg, ctrl, sizeof(*ctrl));
 194         sgs[num_out++] = &outhdr_sg;
 195
 196         sg_init_one(&inhdr_sg, &ctrl_status->status, sizeof(ctrl_status->status));
 197         sgs[num_out + num_in++] = &inhdr_sg;
 198
 199         err = virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, num_in, vc_ctrl_req);
 200         if (err < 0)
 201                 goto out;
 202
 203         if (ctrl_status->status != VIRTIO_CRYPTO_OK) {
 204                 pr_err("virtio_crypto: Close session failed status: %u, session_id: 0x%llx\n",
 205                         ctrl_status->status, destroy_session->session_id);
 206                 err = -EINVAL;
 207                 goto out;
 208         }
 209
 210         err = 0;
 211         ctx->session_valid = false;
 212
 213 out:
 214         kfree(vc_ctrl_req);
 215
 216         return err;
 217 }
 218
 219 static int __virtio_crypto_akcipher_do_req(struct virtio_crypto_akcipher_request *vc_akcipher_req,
 220                 struct akcipher_request *req, struct data_queue *data_vq)
 221 {
 222         struct virtio_crypto_akcipher_ctx *ctx = vc_akcipher_req->akcipher_ctx;
 223         struct virtio_crypto_request *vc_req = &vc_akcipher_req->base;
 224         struct virtio_crypto *vcrypto = ctx->vcrypto;
 225         struct virtio_crypto_op_data_req *req_data = vc_req->req_data;
 226         struct scatterlist *sgs[4], outhdr_sg, inhdr_sg, srcdata_sg, dstdata_sg;
 227         void *src_buf = NULL, *dst_buf = NULL;
 228         unsigned int num_out = 0, num_in = 0;
 229         int node = dev_to_node(&vcrypto->vdev->dev);
 230         unsigned long flags;
 231         int ret = -ENOMEM;
 232         bool verify = vc_akcipher_req->opcode == VIRTIO_CRYPTO_AKCIPHER_VERIFY;
 233         unsigned int src_len = verify ? req->src_len + req->dst_len : req->src_len;
 234
 235         /* out header */
 236         sg_init_one(&outhdr_sg, req_data, sizeof(*req_data));
 237         sgs[num_out++] = &outhdr_sg;
 238
 239         /* src data */
 240         src_buf = kcalloc_node(src_len, 1, GFP_KERNEL, node);
 241         if (!src_buf)
 242                 goto err;
 243
 244         if (verify) {
 245                 /* for verify operation, both src and dst data work as OUT direction */
 246                 sg_copy_to_buffer(req->src, sg_nents(req->src), src_buf, src_len);
 247                 sg_init_one(&srcdata_sg, src_buf, src_len);
 248                 sgs[num_out++] = &srcdata_sg;
 249         } else {
 250                 sg_copy_to_buffer(req->src, sg_nents(req->src), src_buf, src_len);
 251                 sg_init_one(&srcdata_sg, src_buf, src_len);
 252                 sgs[num_out++] = &srcdata_sg;
 253
 254                 /* dst data */
 255                 dst_buf = kcalloc_node(req->dst_len, 1, GFP_KERNEL, node);
 256                 if (!dst_buf)
 257                         goto err;
 258
 259                 sg_init_one(&dstdata_sg, dst_buf, req->dst_len);
 260                 sgs[num_out + num_in++] = &dstdata_sg;
 261         }
 262
 263         vc_akcipher_req->src_buf = src_buf;
 264         vc_akcipher_req->dst_buf = dst_buf;
 265
 266         /* in header */
 267         sg_init_one(&inhdr_sg, &vc_req->status, sizeof(vc_req->status));
 268         sgs[num_out + num_in++] = &inhdr_sg;
 269
 270         spin_lock_irqsave(&data_vq->lock, flags);
 271         ret = virtqueue_add_sgs(data_vq->vq, sgs, num_out, num_in, vc_req, GFP_ATOMIC);
 272         virtqueue_kick(data_vq->vq);
 273         spin_unlock_irqrestore(&data_vq->lock, flags);
 274         if (ret)
 275                 goto err;
 276
 277         return 0;
 278
 279 err:
 280         kfree(src_buf);
 281         kfree(dst_buf);
 282
 283         return -ENOMEM;
 284 }
 285
 286 static int virtio_crypto_rsa_do_req(struct crypto_engine *engine, void *vreq)
 287 {
 288         struct akcipher_request *req = container_of(vreq, struct akcipher_request, base);
 289         struct virtio_crypto_akcipher_request *vc_akcipher_req = akcipher_request_ctx(req);
 290         struct virtio_crypto_request *vc_req = &vc_akcipher_req->base;
 291         struct virtio_crypto_akcipher_ctx *ctx = vc_akcipher_req->akcipher_ctx;
 292         struct virtio_crypto *vcrypto = ctx->vcrypto;
 293         struct data_queue *data_vq = vc_req->dataq;
 294         struct virtio_crypto_op_header *header;
 295         struct virtio_crypto_akcipher_data_req *akcipher_req;
 296         int ret;
 297
 298         vc_req->sgs = NULL;
 299         vc_req->req_data = kzalloc_node(sizeof(*vc_req->req_data),
 300                 GFP_KERNEL, dev_to_node(&vcrypto->vdev->dev));
 301         if (!vc_req->req_data)
 302                 return -ENOMEM;
 303
 304         /* build request header */
 305         header = &vc_req->req_data->header;
 306         header->opcode = cpu_to_le32(vc_akcipher_req->opcode);
 307         header->algo = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_RSA);
 308         header->session_id = cpu_to_le64(ctx->session_id);
 309
 310         /* build request akcipher data */
 311         akcipher_req = &vc_req->req_data->u.akcipher_req;
 312         akcipher_req->para.src_data_len = cpu_to_le32(req->src_len);
 313         akcipher_req->para.dst_data_len = cpu_to_le32(req->dst_len);
 314
 315         ret = __virtio_crypto_akcipher_do_req(vc_akcipher_req, req, data_vq);
 316         if (ret < 0) {
 317                 kfree_sensitive(vc_req->req_data);
 318                 vc_req->req_data = NULL;
 319                 return ret;
 320         }
 321
 322         return 0;
 323 }
 324
 325 static int virtio_crypto_rsa_req(struct akcipher_request *req, uint32_t opcode)
 326 {
 327         struct crypto_akcipher *atfm = crypto_akcipher_reqtfm(req);
 328         struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(atfm);
 329         struct virtio_crypto_akcipher_request *vc_akcipher_req = akcipher_request_ctx(req);
 330         struct virtio_crypto_request *vc_req = &vc_akcipher_req->base;
 331         struct virtio_crypto *vcrypto = ctx->vcrypto;
 332         /* Use the first data virtqueue as default */
 333         struct data_queue *data_vq = &vcrypto->data_vq[0];
 334
 335         vc_req->dataq = data_vq;
 336         vc_req->alg_cb = virtio_crypto_dataq_akcipher_callback;
 337         vc_akcipher_req->akcipher_ctx = ctx;
 338         vc_akcipher_req->akcipher_req = req;
 339         vc_akcipher_req->opcode = opcode;
 340
 341         return crypto_transfer_akcipher_request_to_engine(data_vq->engine, req);
 342 }
 343
 344 static int virtio_crypto_rsa_encrypt(struct akcipher_request *req)
 345 {
 346         return virtio_crypto_rsa_req(req, VIRTIO_CRYPTO_AKCIPHER_ENCRYPT);
 347 }
 348
 349 static int virtio_crypto_rsa_decrypt(struct akcipher_request *req)
 350 {
 351         return virtio_crypto_rsa_req(req, VIRTIO_CRYPTO_AKCIPHER_DECRYPT);
 352 }
 353
 354 static int virtio_crypto_rsa_sign(struct akcipher_request *req)
 355 {
 356         return virtio_crypto_rsa_req(req, VIRTIO_CRYPTO_AKCIPHER_SIGN);
 357 }
 358
 359 static int virtio_crypto_rsa_verify(struct akcipher_request *req)
 360 {
 361         return virtio_crypto_rsa_req(req, VIRTIO_CRYPTO_AKCIPHER_VERIFY);
 362 }
 363
 364 static int virtio_crypto_rsa_set_key(struct crypto_akcipher *tfm,
 365                                      const void *key,
 366                                      unsigned int keylen,
 367                                      bool private,
 368                                      int padding_algo,
 369                                      int hash_algo)
 370 {
 371         struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm);
 372         struct virtio_crypto_rsa_ctx *rsa_ctx = &ctx->rsa_ctx;
 373         struct virtio_crypto *vcrypto;
 374         struct virtio_crypto_ctrl_header header;
 375         struct virtio_crypto_akcipher_session_para para;
 376         struct rsa_key rsa_key = {0};
 377         int node = virtio_crypto_get_current_node();
 378         uint32_t keytype;
 379         int ret;
 380
 381         /* mpi_free will test n, just free it. */
 382         mpi_free(rsa_ctx->n);
 383         rsa_ctx->n = NULL;
 384
 385         if (private) {
 386                 keytype = VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE;
 387                 ret = rsa_parse_priv_key(&rsa_key, key, keylen);
 388         } else {
 389                 keytype = VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC;
 390                 ret = rsa_parse_pub_key(&rsa_key, key, keylen);
 391         }
 392
 393         if (ret)
 394                 return ret;
 395
 396         rsa_ctx->n = mpi_read_raw_data(rsa_key.n, rsa_key.n_sz);
 397         if (!rsa_ctx->n)
 398                 return -ENOMEM;
 399
 400         if (!ctx->vcrypto) {
 401                 vcrypto = virtcrypto_get_dev_node(node, VIRTIO_CRYPTO_SERVICE_AKCIPHER,
 402                                                 VIRTIO_CRYPTO_AKCIPHER_RSA);
 403                 if (!vcrypto) {
 404                         pr_err("virtio_crypto: Could not find a virtio device in the system or unsupported algo\n");
 405                         return -ENODEV;
 406                 }
 407
 408                 ctx->vcrypto = vcrypto;
 409         } else {
 410                 virtio_crypto_alg_akcipher_close_session(ctx);
 411         }
 412
 413         /* set ctrl header */
 414         header.opcode = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_CREATE_SESSION);
 415         header.algo = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_RSA);
 416         header.queue_id = 0;
 417
 418         /* set RSA para */
 419         para.algo = cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_RSA);
 420         para.keytype = cpu_to_le32(keytype);
 421         para.keylen = cpu_to_le32(keylen);
 422         para.u.rsa.padding_algo = cpu_to_le32(padding_algo);
 423         para.u.rsa.hash_algo = cpu_to_le32(hash_algo);
 424
 425         return virtio_crypto_alg_akcipher_init_session(ctx, &header, &para, key, keylen);
 426 }
 427
 428 static int virtio_crypto_rsa_raw_set_priv_key(struct crypto_akcipher *tfm,
 429                                               const void *key,
 430                                               unsigned int keylen)
 431 {
 432         return virtio_crypto_rsa_set_key(tfm, key, keylen, 1,
 433                                          VIRTIO_CRYPTO_RSA_RAW_PADDING,
 434                                          VIRTIO_CRYPTO_RSA_NO_HASH);
 435 }
 436
 437
 438 static int virtio_crypto_p1pad_rsa_sha1_set_priv_key(struct crypto_akcipher *tfm,
 439                                                      const void *key,
 440                                                      unsigned int keylen)
 441 {
 442         return virtio_crypto_rsa_set_key(tfm, key, keylen, 1,
 443                                          VIRTIO_CRYPTO_RSA_PKCS1_PADDING,
 444                                          VIRTIO_CRYPTO_RSA_SHA1);
 445 }
 446
 447 static int virtio_crypto_rsa_raw_set_pub_key(struct crypto_akcipher *tfm,
 448                                              const void *key,
 449                                              unsigned int keylen)
 450 {
 451         return virtio_crypto_rsa_set_key(tfm, key, keylen, 0,
 452                                          VIRTIO_CRYPTO_RSA_RAW_PADDING,
 453                                          VIRTIO_CRYPTO_RSA_NO_HASH);
 454 }
 455
 456 static int virtio_crypto_p1pad_rsa_sha1_set_pub_key(struct crypto_akcipher *tfm,
 457                                                     const void *key,
 458                                                     unsigned int keylen)
 459 {
 460         return virtio_crypto_rsa_set_key(tfm, key, keylen, 0,
 461                                          VIRTIO_CRYPTO_RSA_PKCS1_PADDING,
 462                                          VIRTIO_CRYPTO_RSA_SHA1);
 463 }
 464
 465 static unsigned int virtio_crypto_rsa_max_size(struct crypto_akcipher *tfm)
 466 {
 467         struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm);
 468         struct virtio_crypto_rsa_ctx *rsa_ctx = &ctx->rsa_ctx;
 469
 470         return mpi_get_size(rsa_ctx->n);
 471 }
 472
 473 static int virtio_crypto_rsa_init_tfm(struct crypto_akcipher *tfm)
 474 {
 475         struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm);
 476
 477         ctx->tfm = tfm;
 478
 479         akcipher_set_reqsize(tfm,
 480                              sizeof(struct virtio_crypto_akcipher_request));
 481
 482         return 0;
 483 }
 484
 485 static void virtio_crypto_rsa_exit_tfm(struct crypto_akcipher *tfm)
 486 {
 487         struct virtio_crypto_akcipher_ctx *ctx = akcipher_tfm_ctx(tfm);
 488         struct virtio_crypto_rsa_ctx *rsa_ctx = &ctx->rsa_ctx;
 489
 490         virtio_crypto_alg_akcipher_close_session(ctx);
 491         virtcrypto_dev_put(ctx->vcrypto);
 492         mpi_free(rsa_ctx->n);
 493         rsa_ctx->n = NULL;
 494 }
 495
 496 static struct virtio_crypto_akcipher_algo virtio_crypto_akcipher_algs[] = {
 497         {
 498                 .algonum = VIRTIO_CRYPTO_AKCIPHER_RSA,
 499                 .service = VIRTIO_CRYPTO_SERVICE_AKCIPHER,
 500                 .algo.base = {
 501                         .encrypt = virtio_crypto_rsa_encrypt,
 502                         .decrypt = virtio_crypto_rsa_decrypt,
 503                         .set_pub_key = virtio_crypto_rsa_raw_set_pub_key,
 504                         .set_priv_key = virtio_crypto_rsa_raw_set_priv_key,
 505                         .max_size = virtio_crypto_rsa_max_size,
 506                         .init = virtio_crypto_rsa_init_tfm,
 507                         .exit = virtio_crypto_rsa_exit_tfm,
 508                         .base = {
 509                                 .cra_name = "rsa",
 510                                 .cra_driver_name = "virtio-crypto-rsa",
 511                                 .cra_priority = 150,
 512                                 .cra_module = THIS_MODULE,
 513                                 .cra_ctxsize = sizeof(struct virtio_crypto_akcipher_ctx),
 514                         },
 515                 },
 516                 .algo.op = {
 517                         .do_one_request = virtio_crypto_rsa_do_req,
 518                 },
 519         },
 520         {
 521                 .algonum = VIRTIO_CRYPTO_AKCIPHER_RSA,
 522                 .service = VIRTIO_CRYPTO_SERVICE_AKCIPHER,
 523                 .algo.base = {
 524                         .encrypt = virtio_crypto_rsa_encrypt,
 525                         .decrypt = virtio_crypto_rsa_decrypt,
 526                         .sign = virtio_crypto_rsa_sign,
 527                         .verify = virtio_crypto_rsa_verify,
 528                         .set_pub_key = virtio_crypto_p1pad_rsa_sha1_set_pub_key,
 529                         .set_priv_key = virtio_crypto_p1pad_rsa_sha1_set_priv_key,
 530                         .max_size = virtio_crypto_rsa_max_size,
 531                         .init = virtio_crypto_rsa_init_tfm,
 532                         .exit = virtio_crypto_rsa_exit_tfm,
 533                         .base = {
 534                                 .cra_name = "pkcs1pad(rsa,sha1)",
 535                                 .cra_driver_name = "virtio-pkcs1-rsa-with-sha1",
 536                                 .cra_priority = 150,
 537                                 .cra_module = THIS_MODULE,
 538                                 .cra_ctxsize = sizeof(struct virtio_crypto_akcipher_ctx),
 539                         },
 540                 },
 541                 .algo.op = {
 542                         .do_one_request = virtio_crypto_rsa_do_req,
 543                 },
 544         },
 545 };
 546
 547 int virtio_crypto_akcipher_algs_register(struct virtio_crypto *vcrypto)
 548 {
 549         int ret = 0;
 550         int i = 0;
 551
 552         mutex_lock(&algs_lock);
 553
 554         for (i = 0; i < ARRAY_SIZE(virtio_crypto_akcipher_algs); i++) {
 555                 uint32_t service = virtio_crypto_akcipher_algs[i].service;
 556                 uint32_t algonum = virtio_crypto_akcipher_algs[i].algonum;
 557
 558                 if (!virtcrypto_algo_is_supported(vcrypto, service, algonum))
 559                         continue;
 560
 561                 if (virtio_crypto_akcipher_algs[i].active_devs == 0) {
 562                         ret = crypto_engine_register_akcipher(&virtio_crypto_akcipher_algs[i].algo);
 563                         if (ret)
 564                                 goto unlock;
 565                 }
 566
 567                 virtio_crypto_akcipher_algs[i].active_devs++;
 568                 dev_info(&vcrypto->vdev->dev, "Registered akcipher algo %s\n",
 569                          virtio_crypto_akcipher_algs[i].algo.base.base.cra_name);
 570         }
 571
 572 unlock:
 573         mutex_unlock(&algs_lock);
 574         return ret;
 575 }
 576
 577 void virtio_crypto_akcipher_algs_unregister(struct virtio_crypto *vcrypto)
 578 {
 579         int i = 0;
 580
 581         mutex_lock(&algs_lock);
 582
 583         for (i = 0; i < ARRAY_SIZE(virtio_crypto_akcipher_algs); i++) {
 584                 uint32_t service = virtio_crypto_akcipher_algs[i].service;
 585                 uint32_t algonum = virtio_crypto_akcipher_algs[i].algonum;
 586
 587                 if (virtio_crypto_akcipher_algs[i].active_devs == 0 ||
 588                     !virtcrypto_algo_is_supported(vcrypto, service, algonum))
 589                         continue;
 590
 591                 if (virtio_crypto_akcipher_algs[i].active_devs == 1)
 592                         crypto_engine_unregister_akcipher(&virtio_crypto_akcipher_algs[i].algo);
 593
 594                 virtio_crypto_akcipher_algs[i].active_devs--;
 595         }
 596
 597         mutex_unlock(&algs_lock);
 598 }