[thirdparty/kernel/linux.git] / crypto / akcipher.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Public Key Encryption
 *
 * Copyright (c) 2015, Intel Corporation
 * Authors: Tadeusz Struk <tadeusz.struk@intel.com>
 */
#include <crypto/internal/akcipher.h>
#include <linux/cryptouser.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/scatterlist.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <net/netlink.h>

#include "internal.h"

#define CRYPTO_ALG_TYPE_AHASH_MASK	0x0000000e

static int __maybe_unused crypto_akcipher_report(
	struct sk_buff *skb, struct crypto_alg *alg)
{
	struct crypto_report_akcipher rakcipher;

	memset(&rakcipher, 0, sizeof(rakcipher));

	strscpy(rakcipher.type, "akcipher", sizeof(rakcipher.type));

	return nla_put(skb, CRYPTOCFGA_REPORT_AKCIPHER,
		       sizeof(rakcipher), &rakcipher);
}

static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
	__maybe_unused;

static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
{
	seq_puts(m, "type         : akcipher\n");
}

static void crypto_akcipher_exit_tfm(struct crypto_tfm *tfm)
{
	struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);

	alg->exit(akcipher);
}

static int crypto_akcipher_init_tfm(struct crypto_tfm *tfm)
{
	struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);

	if (alg->exit)
		akcipher->base.exit = crypto_akcipher_exit_tfm;

	if (alg->init)
		return alg->init(akcipher);

	return 0;
}

static void crypto_akcipher_free_instance(struct crypto_instance *inst)
{
	struct akcipher_instance *akcipher = akcipher_instance(inst);

	akcipher->free(akcipher);
}

static int __maybe_unused crypto_akcipher_report_stat(
	struct sk_buff *skb, struct crypto_alg *alg)
{
	struct akcipher_alg *akcipher = __crypto_akcipher_alg(alg);
	struct crypto_istat_akcipher *istat;
	struct crypto_stat_akcipher rakcipher;

	istat = akcipher_get_stat(akcipher);

	memset(&rakcipher, 0, sizeof(rakcipher));

	strscpy(rakcipher.type, "akcipher", sizeof(rakcipher.type));
	rakcipher.stat_encrypt_cnt = atomic64_read(&istat->encrypt_cnt);
	rakcipher.stat_encrypt_tlen = atomic64_read(&istat->encrypt_tlen);
	rakcipher.stat_decrypt_cnt = atomic64_read(&istat->decrypt_cnt);
	rakcipher.stat_decrypt_tlen = atomic64_read(&istat->decrypt_tlen);
	rakcipher.stat_sign_cnt = atomic64_read(&istat->sign_cnt);
	rakcipher.stat_verify_cnt = atomic64_read(&istat->verify_cnt);
	rakcipher.stat_err_cnt = atomic64_read(&istat->err_cnt);

	return nla_put(skb, CRYPTOCFGA_STAT_AKCIPHER,
		       sizeof(rakcipher), &rakcipher);
}

static const struct crypto_type crypto_akcipher_type = {
	.extsize = crypto_alg_extsize,
	.init_tfm = crypto_akcipher_init_tfm,
	.free = crypto_akcipher_free_instance,
#ifdef CONFIG_PROC_FS
	.show = crypto_akcipher_show,
#endif
#if IS_ENABLED(CONFIG_CRYPTO_USER)
	.report = crypto_akcipher_report,
#endif
#ifdef CONFIG_CRYPTO_STATS
	.report_stat = crypto_akcipher_report_stat,
#endif
	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	.maskset = CRYPTO_ALG_TYPE_AHASH_MASK,
	.type = CRYPTO_ALG_TYPE_AKCIPHER,
	.tfmsize = offsetof(struct crypto_akcipher, base),
};

int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn,
			 struct crypto_instance *inst,
			 const char *name, u32 type, u32 mask)
{
	spawn->base.frontend = &crypto_akcipher_type;
	return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_grab_akcipher);

struct crypto_akcipher *crypto_alloc_akcipher(const char *alg_name, u32 type,
					      u32 mask)
{
	return crypto_alloc_tfm(alg_name, &crypto_akcipher_type, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_alloc_akcipher);

static void akcipher_prepare_alg(struct akcipher_alg *alg)
{
	struct crypto_istat_akcipher *istat = akcipher_get_stat(alg);
	struct crypto_alg *base = &alg->base;

	base->cra_type = &crypto_akcipher_type;
	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	base->cra_flags |= CRYPTO_ALG_TYPE_AKCIPHER;

	if (IS_ENABLED(CONFIG_CRYPTO_STATS))
		memset(istat, 0, sizeof(*istat));
}

static int akcipher_default_op(struct akcipher_request *req)
{
	return -ENOSYS;
}

static int akcipher_default_set_key(struct crypto_akcipher *tfm,
				     const void *key, unsigned int keylen)
{
	return -ENOSYS;
}

int crypto_register_akcipher(struct akcipher_alg *alg)
{
	struct crypto_alg *base = &alg->base;

	if (!alg->sign)
		alg->sign = akcipher_default_op;
	if (!alg->verify)
		alg->verify = akcipher_default_op;
	if (!alg->encrypt)
		alg->encrypt = akcipher_default_op;
	if (!alg->decrypt)
		alg->decrypt = akcipher_default_op;
	if (!alg->set_priv_key)
		alg->set_priv_key = akcipher_default_set_key;

	akcipher_prepare_alg(alg);
	return crypto_register_alg(base);
}
EXPORT_SYMBOL_GPL(crypto_register_akcipher);

void crypto_unregister_akcipher(struct akcipher_alg *alg)
{
	crypto_unregister_alg(&alg->base);
}
EXPORT_SYMBOL_GPL(crypto_unregister_akcipher);

int akcipher_register_instance(struct crypto_template *tmpl,
			       struct akcipher_instance *inst)
{
	if (WARN_ON(!inst->free))
		return -EINVAL;
	akcipher_prepare_alg(&inst->alg);
	return crypto_register_instance(tmpl, akcipher_crypto_instance(inst));
}
EXPORT_SYMBOL_GPL(akcipher_register_instance);

int crypto_akcipher_sync_prep(struct crypto_akcipher_sync_data *data)
{
	unsigned int reqsize = crypto_akcipher_reqsize(data->tfm);
	struct akcipher_request *req;
	struct scatterlist *sg;
	unsigned int mlen;
	unsigned int len;
	u8 *buf;

	if (data->dst)
		mlen = max(data->slen, data->dlen);
	else
		mlen = data->slen + data->dlen;

	len = sizeof(*req) + reqsize + mlen;
	if (len < mlen)
		return -EOVERFLOW;

	req = kzalloc(len, GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	data->req = req;
	akcipher_request_set_tfm(req, data->tfm);

	buf = (u8 *)(req + 1) + reqsize;
	data->buf = buf;
	memcpy(buf, data->src, data->slen);

	sg = &data->sg;
	sg_init_one(sg, buf, mlen);
	akcipher_request_set_crypt(req, sg, data->dst ? sg : NULL,
				   data->slen, data->dlen);

	crypto_init_wait(&data->cwait);
	akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
				      crypto_req_done, &data->cwait);

	return 0;
}
EXPORT_SYMBOL_GPL(crypto_akcipher_sync_prep);

int crypto_akcipher_sync_post(struct crypto_akcipher_sync_data *data, int err)
{
	err = crypto_wait_req(err, &data->cwait);
	if (data->dst)
		memcpy(data->dst, data->buf, data->dlen);
	data->dlen = data->req->dst_len;
	kfree_sensitive(data->req);
	return err;
}
EXPORT_SYMBOL_GPL(crypto_akcipher_sync_post);

int crypto_akcipher_sync_encrypt(struct crypto_akcipher *tfm,
				 const void *src, unsigned int slen,
				 void *dst, unsigned int dlen)
{
	struct crypto_akcipher_sync_data data = {
		.tfm = tfm,
		.src = src,
		.dst = dst,
		.slen = slen,
		.dlen = dlen,
	};

	return crypto_akcipher_sync_prep(&data) ?:
	       crypto_akcipher_sync_post(&data,
					 crypto_akcipher_encrypt(data.req));
}
EXPORT_SYMBOL_GPL(crypto_akcipher_sync_encrypt);

int crypto_akcipher_sync_decrypt(struct crypto_akcipher *tfm,
				 const void *src, unsigned int slen,
				 void *dst, unsigned int dlen)
{
	struct crypto_akcipher_sync_data data = {
		.tfm = tfm,
		.src = src,
		.dst = dst,
		.slen = slen,
		.dlen = dlen,
	};

	return crypto_akcipher_sync_prep(&data) ?:
	       crypto_akcipher_sync_post(&data,
					 crypto_akcipher_decrypt(data.req)) ?:
	       data.dlen;
}
EXPORT_SYMBOL_GPL(crypto_akcipher_sync_decrypt);

static void crypto_exit_akcipher_ops_sig(struct crypto_tfm *tfm)
{
	struct crypto_akcipher **ctx = crypto_tfm_ctx(tfm);

	crypto_free_akcipher(*ctx);
}

int crypto_init_akcipher_ops_sig(struct crypto_tfm *tfm)
{
	struct crypto_akcipher **ctx = crypto_tfm_ctx(tfm);
	struct crypto_alg *calg = tfm->__crt_alg;
	struct crypto_akcipher *akcipher;

	if (!crypto_mod_get(calg))
		return -EAGAIN;

	akcipher = crypto_create_tfm(calg, &crypto_akcipher_type);
	if (IS_ERR(akcipher)) {
		crypto_mod_put(calg);
		return PTR_ERR(akcipher);
	}

	*ctx = akcipher;
	tfm->exit = crypto_exit_akcipher_ops_sig;

	return 0;
}
EXPORT_SYMBOL_GPL(crypto_init_akcipher_ops_sig);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Generic public key cipher type");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
3c339ab8 TS	2	/*
	3	* Public Key Encryption
	4	*
	5	* Copyright (c) 2015, Intel Corporation
	6	* Authors: Tadeusz Struk <tadeusz.struk@intel.com>
3c339ab8	7	*/
035d78a1 HX	8	#include <crypto/internal/akcipher.h>
035d78a1 HX	9	#include <linux/cryptouser.h>
3c339ab8 TS	10	#include <linux/errno.h>
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
addde1f2	13	#include <linux/scatterlist.h>
3c339ab8 TS	14	#include <linux/seq_file.h>
	15	#include <linux/slab.h>
	16	#include <linux/string.h>
3c339ab8	17	#include <net/netlink.h>
035d78a1	18
3c339ab8 TS	19	#include "internal.h"
3c339ab8 TS	20
6cb8815f	21	#define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e
addde1f2	22
c0f9e01d HX	23	static int __maybe_unused crypto_akcipher_report(
c0f9e01d HX	24	struct sk_buff skb, struct crypto_alg alg)
3c339ab8 TS	25	{
	26	struct crypto_report_akcipher rakcipher;
	27
37db69e0	28	memset(&rakcipher, 0, sizeof(rakcipher));
3c339ab8	29
37db69e0	30	strscpy(rakcipher.type, "akcipher", sizeof(rakcipher.type));
3c339ab8	31
37db69e0 EB	32	return nla_put(skb, CRYPTOCFGA_REPORT_AKCIPHER,
37db69e0 EB	33	sizeof(rakcipher), &rakcipher);
3c339ab8	34	}
3c339ab8 TS	35
3c339ab8 TS	36	static void crypto_akcipher_show(struct seq_file m, struct crypto_alg alg)
d8c34b94	37	__maybe_unused;
3c339ab8 TS	38
	39	static void crypto_akcipher_show(struct seq_file m, struct crypto_alg alg)
	40	{
	41	seq_puts(m, "type : akcipher\n");
	42	}
	43
	44	static void crypto_akcipher_exit_tfm(struct crypto_tfm *tfm)
	45	{
	46	struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
	47	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
	48
	49	alg->exit(akcipher);
	50	}
	51
	52	static int crypto_akcipher_init_tfm(struct crypto_tfm *tfm)
	53	{
	54	struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
	55	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
	56
	57	if (alg->exit)
	58	akcipher->base.exit = crypto_akcipher_exit_tfm;
	59
	60	if (alg->init)
	61	return alg->init(akcipher);
	62
	63	return 0;
	64	}
	65
28a4618a AZ	66	static void crypto_akcipher_free_instance(struct crypto_instance *inst)
	67	{
	68	struct akcipher_instance *akcipher = akcipher_instance(inst);
	69
	70	akcipher->free(akcipher);
	71	}
	72
035d78a1 HX	73	static int __maybe_unused crypto_akcipher_report_stat(
	74	struct sk_buff skb, struct crypto_alg alg)
	75	{
	76	struct akcipher_alg *akcipher = __crypto_akcipher_alg(alg);
	77	struct crypto_istat_akcipher *istat;
	78	struct crypto_stat_akcipher rakcipher;
	79
	80	istat = akcipher_get_stat(akcipher);
	81
	82	memset(&rakcipher, 0, sizeof(rakcipher));
	83
	84	strscpy(rakcipher.type, "akcipher", sizeof(rakcipher.type));
	85	rakcipher.stat_encrypt_cnt = atomic64_read(&istat->encrypt_cnt);
	86	rakcipher.stat_encrypt_tlen = atomic64_read(&istat->encrypt_tlen);
	87	rakcipher.stat_decrypt_cnt = atomic64_read(&istat->decrypt_cnt);
	88	rakcipher.stat_decrypt_tlen = atomic64_read(&istat->decrypt_tlen);
	89	rakcipher.stat_sign_cnt = atomic64_read(&istat->sign_cnt);
	90	rakcipher.stat_verify_cnt = atomic64_read(&istat->verify_cnt);
	91	rakcipher.stat_err_cnt = atomic64_read(&istat->err_cnt);
	92
	93	return nla_put(skb, CRYPTOCFGA_STAT_AKCIPHER,
	94	sizeof(rakcipher), &rakcipher);
	95	}
	96
3c339ab8 TS	97	static const struct crypto_type crypto_akcipher_type = {
	98	.extsize = crypto_alg_extsize,
	99	.init_tfm = crypto_akcipher_init_tfm,
28a4618a	100	.free = crypto_akcipher_free_instance,
3c339ab8 TS	101	#ifdef CONFIG_PROC_FS
	102	.show = crypto_akcipher_show,
	103	#endif
b8969a1b	104	#if IS_ENABLED(CONFIG_CRYPTO_USER)
3c339ab8	105	.report = crypto_akcipher_report,
c0f9e01d	106	#endif
035d78a1 HX	107	#ifdef CONFIG_CRYPTO_STATS
	108	.report_stat = crypto_akcipher_report_stat,
	109	#endif
3c339ab8	110	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
6cb8815f	111	.maskset = CRYPTO_ALG_TYPE_AHASH_MASK,
3c339ab8 TS	112	.type = CRYPTO_ALG_TYPE_AKCIPHER,
	113	.tfmsize = offsetof(struct crypto_akcipher, base),
	114	};
	115
73bed26f EB	116	int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn,
	117	struct crypto_instance *inst,
	118	const char *name, u32 type, u32 mask)
28a4618a AZ	119	{
28a4618a AZ	120	spawn->base.frontend = &crypto_akcipher_type;
de95c957	121	return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
28a4618a AZ	122	}
	123	EXPORT_SYMBOL_GPL(crypto_grab_akcipher);
	124
3c339ab8 TS	125	struct crypto_akcipher crypto_alloc_akcipher(const char alg_name, u32 type,
	126	u32 mask)
	127	{
	128	return crypto_alloc_tfm(alg_name, &crypto_akcipher_type, type, mask);
	129	}
	130	EXPORT_SYMBOL_GPL(crypto_alloc_akcipher);
	131
28a4618a	132	static void akcipher_prepare_alg(struct akcipher_alg *alg)
3c339ab8	133	{
035d78a1	134	struct crypto_istat_akcipher *istat = akcipher_get_stat(alg);
3c339ab8 TS	135	struct crypto_alg *base = &alg->base;
	136
	137	base->cra_type = &crypto_akcipher_type;
	138	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	139	base->cra_flags \|= CRYPTO_ALG_TYPE_AKCIPHER;
035d78a1 HX	140
	141	if (IS_ENABLED(CONFIG_CRYPTO_STATS))
	142	memset(istat, 0, sizeof(*istat));
28a4618a AZ	143	}
28a4618a AZ	144
78a0324f VC	145	static int akcipher_default_op(struct akcipher_request *req)
	146	{
	147	return -ENOSYS;
	148	}
	149
bc155c6c IK	150	static int akcipher_default_set_key(struct crypto_akcipher *tfm,
	151	const void *key, unsigned int keylen)
	152	{
	153	return -ENOSYS;
	154	}
	155
28a4618a AZ	156	int crypto_register_akcipher(struct akcipher_alg *alg)
	157	{
	158	struct crypto_alg *base = &alg->base;
	159
78a0324f VC	160	if (!alg->sign)
	161	alg->sign = akcipher_default_op;
	162	if (!alg->verify)
	163	alg->verify = akcipher_default_op;
	164	if (!alg->encrypt)
	165	alg->encrypt = akcipher_default_op;
	166	if (!alg->decrypt)
	167	alg->decrypt = akcipher_default_op;
bc155c6c IK	168	if (!alg->set_priv_key)
bc155c6c IK	169	alg->set_priv_key = akcipher_default_set_key;
78a0324f	170
28a4618a	171	akcipher_prepare_alg(alg);
3c339ab8 TS	172	return crypto_register_alg(base);
	173	}
	174	EXPORT_SYMBOL_GPL(crypto_register_akcipher);
	175
	176	void crypto_unregister_akcipher(struct akcipher_alg *alg)
	177	{
	178	crypto_unregister_alg(&alg->base);
	179	}
	180	EXPORT_SYMBOL_GPL(crypto_unregister_akcipher);
	181
28a4618a AZ	182	int akcipher_register_instance(struct crypto_template *tmpl,
	183	struct akcipher_instance *inst)
	184	{
d4fdc2df EB	185	if (WARN_ON(!inst->free))
d4fdc2df EB	186	return -EINVAL;
28a4618a AZ	187	akcipher_prepare_alg(&inst->alg);
	188	return crypto_register_instance(tmpl, akcipher_crypto_instance(inst));
	189	}
	190	EXPORT_SYMBOL_GPL(akcipher_register_instance);
	191
6cb8815f	192	int crypto_akcipher_sync_prep(struct crypto_akcipher_sync_data *data)
addde1f2 HX	193	{
addde1f2 HX	194	unsigned int reqsize = crypto_akcipher_reqsize(data->tfm);
addde1f2 HX	195	struct akcipher_request *req;
addde1f2 HX	196	struct scatterlist *sg;
891ebfdf	197	unsigned int mlen;
addde1f2 HX	198	unsigned int len;
	199	u8 *buf;
	200
891ebfdf HX	201	if (data->dst)
	202	mlen = max(data->slen, data->dlen);
	203	else
	204	mlen = data->slen + data->dlen;
	205
addde1f2 HX	206	len = sizeof(*req) + reqsize + mlen;
	207	if (len < mlen)
	208	return -EOVERFLOW;
	209
	210	req = kzalloc(len, GFP_KERNEL);
	211	if (!req)
	212	return -ENOMEM;
	213
	214	data->req = req;
767cfee8	215	akcipher_request_set_tfm(req, data->tfm);
addde1f2 HX	216
	217	buf = (u8 *)(req + 1) + reqsize;
	218	data->buf = buf;
	219	memcpy(buf, data->src, data->slen);
	220
891ebfdf	221	sg = &data->sg;
addde1f2	222	sg_init_one(sg, buf, mlen);
891ebfdf HX	223	akcipher_request_set_crypt(req, sg, data->dst ? sg : NULL,
891ebfdf HX	224	data->slen, data->dlen);
addde1f2 HX	225
	226	crypto_init_wait(&data->cwait);
	227	akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
	228	crypto_req_done, &data->cwait);
	229
	230	return 0;
	231	}
6cb8815f	232	EXPORT_SYMBOL_GPL(crypto_akcipher_sync_prep);
addde1f2	233
6cb8815f	234	int crypto_akcipher_sync_post(struct crypto_akcipher_sync_data *data, int err)
addde1f2 HX	235	{
addde1f2 HX	236	err = crypto_wait_req(err, &data->cwait);
486bfb05 HX	237	if (data->dst)
486bfb05 HX	238	memcpy(data->dst, data->buf, data->dlen);
addde1f2 HX	239	data->dlen = data->req->dst_len;
	240	kfree_sensitive(data->req);
	241	return err;
	242	}
6cb8815f	243	EXPORT_SYMBOL_GPL(crypto_akcipher_sync_post);
addde1f2 HX	244
	245	int crypto_akcipher_sync_encrypt(struct crypto_akcipher *tfm,
	246	const void *src, unsigned int slen,
	247	void *dst, unsigned int dlen)
	248	{
	249	struct crypto_akcipher_sync_data data = {
	250	.tfm = tfm,
	251	.src = src,
	252	.dst = dst,
	253	.slen = slen,
	254	.dlen = dlen,
	255	};
	256
	257	return crypto_akcipher_sync_prep(&data) ?:
	258	crypto_akcipher_sync_post(&data,
	259	crypto_akcipher_encrypt(data.req));
	260	}
	261	EXPORT_SYMBOL_GPL(crypto_akcipher_sync_encrypt);
	262
	263	int crypto_akcipher_sync_decrypt(struct crypto_akcipher *tfm,
	264	const void *src, unsigned int slen,
	265	void *dst, unsigned int dlen)
	266	{
	267	struct crypto_akcipher_sync_data data = {
	268	.tfm = tfm,
	269	.src = src,
	270	.dst = dst,
	271	.slen = slen,
	272	.dlen = dlen,
	273	};
	274
	275	return crypto_akcipher_sync_prep(&data) ?:
	276	crypto_akcipher_sync_post(&data,
	277	crypto_akcipher_decrypt(data.req)) ?:
	278	data.dlen;
	279	}
	280	EXPORT_SYMBOL_GPL(crypto_akcipher_sync_decrypt);
	281
6cb8815f HX	282	static void crypto_exit_akcipher_ops_sig(struct crypto_tfm *tfm)
	283	{
	284	struct crypto_akcipher **ctx = crypto_tfm_ctx(tfm);
	285
	286	crypto_free_akcipher(*ctx);
	287	}
	288
	289	int crypto_init_akcipher_ops_sig(struct crypto_tfm *tfm)
	290	{
	291	struct crypto_akcipher **ctx = crypto_tfm_ctx(tfm);
	292	struct crypto_alg *calg = tfm->__crt_alg;
	293	struct crypto_akcipher *akcipher;
	294
	295	if (!crypto_mod_get(calg))
	296	return -EAGAIN;
	297
	298	akcipher = crypto_create_tfm(calg, &crypto_akcipher_type);
	299	if (IS_ERR(akcipher)) {
	300	crypto_mod_put(calg);
	301	return PTR_ERR(akcipher);
	302	}
	303
	304	*ctx = akcipher;
	305	tfm->exit = crypto_exit_akcipher_ops_sig;
	306
	307	return 0;
	308	}
	309	EXPORT_SYMBOL_GPL(crypto_init_akcipher_ops_sig);
	310
3c339ab8	311	MODULE_LICENSE("GPL");
338a9de0	312	MODULE_DESCRIPTION("Generic public key cipher type");