[linux.git] / crypto / akcipher.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Public Key Encryption
 *
 * Copyright (c) 2015, Intel Corporation
 * Authors: Tadeusz Struk <[email protected]>
 */
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/crypto.h>
#include <linux/compiler.h>
#include <crypto/algapi.h>
#include <linux/cryptouser.h>
#include <net/netlink.h>
#include <crypto/akcipher.h>
#include <crypto/internal/akcipher.h>
#include "internal.h"

#ifdef CONFIG_NET
static int 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);
}
#else
static int crypto_akcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
{
	return -ENOSYS;
}
#endif

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 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
	.report = crypto_akcipher_report,
	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	.maskset = CRYPTO_ALG_TYPE_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_alg *base = &alg->base;

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

static int akcipher_default_op(struct akcipher_request *req)
{
	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;

	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);

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 <[email protected]>
3c339ab8 TS	7	*/
	8	#include <linux/errno.h>
	9	#include <linux/kernel.h>
	10	#include <linux/module.h>
	11	#include <linux/seq_file.h>
	12	#include <linux/slab.h>
	13	#include <linux/string.h>
	14	#include <linux/crypto.h>
d8c34b94	15	#include <linux/compiler.h>
3c339ab8 TS	16	#include <crypto/algapi.h>
	17	#include <linux/cryptouser.h>
	18	#include <net/netlink.h>
	19	#include <crypto/akcipher.h>
28a4618a	20	#include <crypto/internal/akcipher.h>
3c339ab8 TS	21	#include "internal.h"
	22
	23	#ifdef CONFIG_NET
	24	static int crypto_akcipher_report(struct sk_buff skb, struct crypto_alg alg)
	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 TS	34	}
	35	#else
	36	static int crypto_akcipher_report(struct sk_buff skb, struct crypto_alg alg)
	37	{
	38	return -ENOSYS;
	39	}
	40	#endif
	41
	42	static void crypto_akcipher_show(struct seq_file m, struct crypto_alg alg)
d8c34b94	43	__maybe_unused;
3c339ab8 TS	44
	45	static void crypto_akcipher_show(struct seq_file m, struct crypto_alg alg)
	46	{
	47	seq_puts(m, "type : akcipher\n");
	48	}
	49
	50	static void crypto_akcipher_exit_tfm(struct crypto_tfm *tfm)
	51	{
	52	struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
	53	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
	54
	55	alg->exit(akcipher);
	56	}
	57
	58	static int crypto_akcipher_init_tfm(struct crypto_tfm *tfm)
	59	{
	60	struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
	61	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
	62
	63	if (alg->exit)
	64	akcipher->base.exit = crypto_akcipher_exit_tfm;
	65
	66	if (alg->init)
	67	return alg->init(akcipher);
	68
	69	return 0;
	70	}
	71
28a4618a AZ	72	static void crypto_akcipher_free_instance(struct crypto_instance *inst)
	73	{
	74	struct akcipher_instance *akcipher = akcipher_instance(inst);
	75
	76	akcipher->free(akcipher);
	77	}
	78
3c339ab8 TS	79	static const struct crypto_type crypto_akcipher_type = {
	80	.extsize = crypto_alg_extsize,
	81	.init_tfm = crypto_akcipher_init_tfm,
28a4618a	82	.free = crypto_akcipher_free_instance,
3c339ab8 TS	83	#ifdef CONFIG_PROC_FS
	84	.show = crypto_akcipher_show,
	85	#endif
	86	.report = crypto_akcipher_report,
	87	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	88	.maskset = CRYPTO_ALG_TYPE_MASK,
	89	.type = CRYPTO_ALG_TYPE_AKCIPHER,
	90	.tfmsize = offsetof(struct crypto_akcipher, base),
	91	};
	92
73bed26f EB	93	int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn,
	94	struct crypto_instance *inst,
	95	const char *name, u32 type, u32 mask)
28a4618a AZ	96	{
28a4618a AZ	97	spawn->base.frontend = &crypto_akcipher_type;
de95c957	98	return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
28a4618a AZ	99	}
	100	EXPORT_SYMBOL_GPL(crypto_grab_akcipher);
	101
3c339ab8 TS	102	struct crypto_akcipher crypto_alloc_akcipher(const char alg_name, u32 type,
	103	u32 mask)
	104	{
	105	return crypto_alloc_tfm(alg_name, &crypto_akcipher_type, type, mask);
	106	}
	107	EXPORT_SYMBOL_GPL(crypto_alloc_akcipher);
	108
28a4618a	109	static void akcipher_prepare_alg(struct akcipher_alg *alg)
3c339ab8 TS	110	{
	111	struct crypto_alg *base = &alg->base;
	112
	113	base->cra_type = &crypto_akcipher_type;
	114	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	115	base->cra_flags \|= CRYPTO_ALG_TYPE_AKCIPHER;
28a4618a AZ	116	}
28a4618a AZ	117
78a0324f VC	118	static int akcipher_default_op(struct akcipher_request *req)
	119	{
	120	return -ENOSYS;
	121	}
	122
28a4618a AZ	123	int crypto_register_akcipher(struct akcipher_alg *alg)
	124	{
	125	struct crypto_alg *base = &alg->base;
	126
78a0324f VC	127	if (!alg->sign)
	128	alg->sign = akcipher_default_op;
	129	if (!alg->verify)
	130	alg->verify = akcipher_default_op;
	131	if (!alg->encrypt)
	132	alg->encrypt = akcipher_default_op;
	133	if (!alg->decrypt)
	134	alg->decrypt = akcipher_default_op;
	135
28a4618a	136	akcipher_prepare_alg(alg);
3c339ab8 TS	137	return crypto_register_alg(base);
	138	}
	139	EXPORT_SYMBOL_GPL(crypto_register_akcipher);
	140
	141	void crypto_unregister_akcipher(struct akcipher_alg *alg)
	142	{
	143	crypto_unregister_alg(&alg->base);
	144	}
	145	EXPORT_SYMBOL_GPL(crypto_unregister_akcipher);
	146
28a4618a AZ	147	int akcipher_register_instance(struct crypto_template *tmpl,
	148	struct akcipher_instance *inst)
	149	{
d4fdc2df EB	150	if (WARN_ON(!inst->free))
d4fdc2df EB	151	return -EINVAL;
28a4618a AZ	152	akcipher_prepare_alg(&inst->alg);
	153	return crypto_register_instance(tmpl, akcipher_crypto_instance(inst));
	154	}
	155	EXPORT_SYMBOL_GPL(akcipher_register_instance);
	156
3c339ab8	157	MODULE_LICENSE("GPL");
338a9de0	158	MODULE_DESCRIPTION("Generic public key cipher type");