linux/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c

// SPDX-License-Identifier: GPL-2.0-or-later
 /* Asymmetric algorithms supported by virtio crypto device
  *
  * Authors: zhenwei pi <[email protected]>
  *          lei he <[email protected]>
  *
  * Copyright 2022 Bytedance CO., LTD.
  */

#include <crypto/engine.h>
#include <crypto/internal/akcipher.h>
#include <crypto/internal/rsa.h>
#include <crypto/scatterwalk.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/mpi.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <uapi/linux/virtio_crypto.h>
#include "virtio_crypto_common.h"

struct virtio_crypto_rsa_ctx { … };

struct virtio_crypto_akcipher_ctx { … };

struct virtio_crypto_akcipher_request { … };

struct virtio_crypto_akcipher_algo { … };

static DEFINE_MUTEX(algs_lock);

static void virtio_crypto_akcipher_finalize_req(
	struct virtio_crypto_akcipher_request *vc_akcipher_req,
	struct akcipher_request *req, int err)
{ … }

static void virtio_crypto_dataq_akcipher_callback(struct virtio_crypto_request *vc_req, int len)
{ … }

static int virtio_crypto_alg_akcipher_init_session(struct virtio_crypto_akcipher_ctx *ctx,
		struct virtio_crypto_ctrl_header *header,
		struct virtio_crypto_akcipher_session_para *para,
		const uint8_t *key, unsigned int keylen)
{ … }

static int virtio_crypto_alg_akcipher_close_session(struct virtio_crypto_akcipher_ctx *ctx)
{ … }

static int __virtio_crypto_akcipher_do_req(struct virtio_crypto_akcipher_request *vc_akcipher_req,
		struct akcipher_request *req, struct data_queue *data_vq)
{ … }

static int virtio_crypto_rsa_do_req(struct crypto_engine *engine, void *vreq)
{ … }

static int virtio_crypto_rsa_req(struct akcipher_request *req, uint32_t opcode)
{ … }

static int virtio_crypto_rsa_encrypt(struct akcipher_request *req)
{ … }

static int virtio_crypto_rsa_decrypt(struct akcipher_request *req)
{ … }

static int virtio_crypto_rsa_sign(struct akcipher_request *req)
{ … }

static int virtio_crypto_rsa_verify(struct akcipher_request *req)
{ … }

static int virtio_crypto_rsa_set_key(struct crypto_akcipher *tfm,
				     const void *key,
				     unsigned int keylen,
				     bool private,
				     int padding_algo,
				     int hash_algo)
{ … }

static int virtio_crypto_rsa_raw_set_priv_key(struct crypto_akcipher *tfm,
					      const void *key,
					      unsigned int keylen)
{ … }


static int virtio_crypto_p1pad_rsa_sha1_set_priv_key(struct crypto_akcipher *tfm,
						     const void *key,
						     unsigned int keylen)
{ … }

static int virtio_crypto_rsa_raw_set_pub_key(struct crypto_akcipher *tfm,
					     const void *key,
					     unsigned int keylen)
{ … }

static int virtio_crypto_p1pad_rsa_sha1_set_pub_key(struct crypto_akcipher *tfm,
						    const void *key,
						    unsigned int keylen)
{ … }

static unsigned int virtio_crypto_rsa_max_size(struct crypto_akcipher *tfm)
{ … }

static int virtio_crypto_rsa_init_tfm(struct crypto_akcipher *tfm)
{ … }

static void virtio_crypto_rsa_exit_tfm(struct crypto_akcipher *tfm)
{ … }

static struct virtio_crypto_akcipher_algo virtio_crypto_akcipher_algs[] = …;

int virtio_crypto_akcipher_algs_register(struct virtio_crypto *vcrypto)
{ … }

void virtio_crypto_akcipher_algs_unregister(struct virtio_crypto *vcrypto)
{ … }