[linux-block.git] / crypto / kpp.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Key-agreement Protocol Primitives (KPP)
 *
 * Copyright (c) 2016, Intel Corporation
 * Authors: Salvatore Benedetto <salvatore.benedetto@intel.com>
 */
#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 <crypto/algapi.h>
#include <linux/cryptouser.h>
#include <linux/compiler.h>
#include <net/netlink.h>
#include <crypto/kpp.h>
#include <crypto/internal/kpp.h>
#include "internal.h"

#ifdef CONFIG_NET
static int crypto_kpp_report(struct sk_buff *skb, struct crypto_alg *alg)
{
	struct crypto_report_kpp rkpp;

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

	strscpy(rkpp.type, "kpp", sizeof(rkpp.type));

	return nla_put(skb, CRYPTOCFGA_REPORT_KPP, sizeof(rkpp), &rkpp);
}
#else
static int crypto_kpp_report(struct sk_buff *skb, struct crypto_alg *alg)
{
	return -ENOSYS;
}
#endif

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

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

static void crypto_kpp_exit_tfm(struct crypto_tfm *tfm)
{
	struct crypto_kpp *kpp = __crypto_kpp_tfm(tfm);
	struct kpp_alg *alg = crypto_kpp_alg(kpp);

	alg->exit(kpp);
}

static int crypto_kpp_init_tfm(struct crypto_tfm *tfm)
{
	struct crypto_kpp *kpp = __crypto_kpp_tfm(tfm);
	struct kpp_alg *alg = crypto_kpp_alg(kpp);

	if (alg->exit)
		kpp->base.exit = crypto_kpp_exit_tfm;

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

	return 0;
}

static void crypto_kpp_free_instance(struct crypto_instance *inst)
{
	struct kpp_instance *kpp = kpp_instance(inst);

	kpp->free(kpp);
}

static const struct crypto_type crypto_kpp_type = {
	.extsize = crypto_alg_extsize,
	.init_tfm = crypto_kpp_init_tfm,
	.free = crypto_kpp_free_instance,
#ifdef CONFIG_PROC_FS
	.show = crypto_kpp_show,
#endif
	.report = crypto_kpp_report,
	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	.maskset = CRYPTO_ALG_TYPE_MASK,
	.type = CRYPTO_ALG_TYPE_KPP,
	.tfmsize = offsetof(struct crypto_kpp, base),
};

struct crypto_kpp *crypto_alloc_kpp(const char *alg_name, u32 type, u32 mask)
{
	return crypto_alloc_tfm(alg_name, &crypto_kpp_type, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_alloc_kpp);

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

int crypto_has_kpp(const char *alg_name, u32 type, u32 mask)
{
	return crypto_type_has_alg(alg_name, &crypto_kpp_type, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_has_kpp);

static void kpp_prepare_alg(struct kpp_alg *alg)
{
	struct crypto_alg *base = &alg->base;

	base->cra_type = &crypto_kpp_type;
	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	base->cra_flags |= CRYPTO_ALG_TYPE_KPP;
}

int crypto_register_kpp(struct kpp_alg *alg)
{
	struct crypto_alg *base = &alg->base;

	kpp_prepare_alg(alg);
	return crypto_register_alg(base);
}
EXPORT_SYMBOL_GPL(crypto_register_kpp);

void crypto_unregister_kpp(struct kpp_alg *alg)
{
	crypto_unregister_alg(&alg->base);
}
EXPORT_SYMBOL_GPL(crypto_unregister_kpp);

int kpp_register_instance(struct crypto_template *tmpl,
			  struct kpp_instance *inst)
{
	if (WARN_ON(!inst->free))
		return -EINVAL;

	kpp_prepare_alg(&inst->alg);

	return crypto_register_instance(tmpl, kpp_crypto_instance(inst));
}
EXPORT_SYMBOL_GPL(kpp_register_instance);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Key-agreement Protocol Primitives");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
4e5f2c40 SB	2	/*
	3	* Key-agreement Protocol Primitives (KPP)
	4	*
	5	* Copyright (c) 2016, Intel Corporation
	6	* Authors: Salvatore Benedetto <salvatore.benedetto@intel.com>
4e5f2c40 SB	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>
	15	#include <crypto/algapi.h>
	16	#include <linux/cryptouser.h>
d8c34b94	17	#include <linux/compiler.h>
4e5f2c40 SB	18	#include <net/netlink.h>
	19	#include <crypto/kpp.h>
	20	#include <crypto/internal/kpp.h>
	21	#include "internal.h"
	22
	23	#ifdef CONFIG_NET
	24	static int crypto_kpp_report(struct sk_buff skb, struct crypto_alg alg)
	25	{
	26	struct crypto_report_kpp rkpp;
	27
37db69e0	28	memset(&rkpp, 0, sizeof(rkpp));
4e5f2c40	29
37db69e0	30	strscpy(rkpp.type, "kpp", sizeof(rkpp.type));
4e5f2c40	31
37db69e0	32	return nla_put(skb, CRYPTOCFGA_REPORT_KPP, sizeof(rkpp), &rkpp);
4e5f2c40 SB	33	}
	34	#else
	35	static int crypto_kpp_report(struct sk_buff skb, struct crypto_alg alg)
	36	{
	37	return -ENOSYS;
	38	}
	39	#endif
	40
	41	static void crypto_kpp_show(struct seq_file m, struct crypto_alg alg)
d8c34b94	42	__maybe_unused;
4e5f2c40 SB	43
	44	static void crypto_kpp_show(struct seq_file m, struct crypto_alg alg)
	45	{
	46	seq_puts(m, "type : kpp\n");
	47	}
	48
	49	static void crypto_kpp_exit_tfm(struct crypto_tfm *tfm)
	50	{
	51	struct crypto_kpp *kpp = __crypto_kpp_tfm(tfm);
	52	struct kpp_alg *alg = crypto_kpp_alg(kpp);
	53
	54	alg->exit(kpp);
	55	}
	56
	57	static int crypto_kpp_init_tfm(struct crypto_tfm *tfm)
	58	{
	59	struct crypto_kpp *kpp = __crypto_kpp_tfm(tfm);
	60	struct kpp_alg *alg = crypto_kpp_alg(kpp);
	61
	62	if (alg->exit)
	63	kpp->base.exit = crypto_kpp_exit_tfm;
	64
	65	if (alg->init)
	66	return alg->init(kpp);
	67
	68	return 0;
	69	}
	70
1038fd78 NS	71	static void crypto_kpp_free_instance(struct crypto_instance *inst)
	72	{
	73	struct kpp_instance *kpp = kpp_instance(inst);
	74
	75	kpp->free(kpp);
	76	}
	77
4e5f2c40 SB	78	static const struct crypto_type crypto_kpp_type = {
	79	.extsize = crypto_alg_extsize,
	80	.init_tfm = crypto_kpp_init_tfm,
1038fd78	81	.free = crypto_kpp_free_instance,
4e5f2c40 SB	82	#ifdef CONFIG_PROC_FS
	83	.show = crypto_kpp_show,
	84	#endif
	85	.report = crypto_kpp_report,
	86	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	87	.maskset = CRYPTO_ALG_TYPE_MASK,
	88	.type = CRYPTO_ALG_TYPE_KPP,
	89	.tfmsize = offsetof(struct crypto_kpp, base),
	90	};
	91
	92	struct crypto_kpp crypto_alloc_kpp(const char alg_name, u32 type, u32 mask)
	93	{
	94	return crypto_alloc_tfm(alg_name, &crypto_kpp_type, type, mask);
	95	}
	96	EXPORT_SYMBOL_GPL(crypto_alloc_kpp);
	97
46ed5269 NS	98	int crypto_grab_kpp(struct crypto_kpp_spawn *spawn,
	99	struct crypto_instance *inst,
	100	const char *name, u32 type, u32 mask)
	101	{
	102	spawn->base.frontend = &crypto_kpp_type;
	103	return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
	104	}
	105	EXPORT_SYMBOL_GPL(crypto_grab_kpp);
	106
9e2f284e HR	107	int crypto_has_kpp(const char *alg_name, u32 type, u32 mask)
	108	{
	109	return crypto_type_has_alg(alg_name, &crypto_kpp_type, type, mask);
	110	}
	111	EXPORT_SYMBOL_GPL(crypto_has_kpp);
	112
4e5f2c40 SB	113	static void kpp_prepare_alg(struct kpp_alg *alg)
	114	{
	115	struct crypto_alg *base = &alg->base;
	116
	117	base->cra_type = &crypto_kpp_type;
	118	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	119	base->cra_flags \|= CRYPTO_ALG_TYPE_KPP;
	120	}
	121
	122	int crypto_register_kpp(struct kpp_alg *alg)
	123	{
	124	struct crypto_alg *base = &alg->base;
	125
	126	kpp_prepare_alg(alg);
	127	return crypto_register_alg(base);
	128	}
	129	EXPORT_SYMBOL_GPL(crypto_register_kpp);
	130
	131	void crypto_unregister_kpp(struct kpp_alg *alg)
	132	{
	133	crypto_unregister_alg(&alg->base);
	134	}
	135	EXPORT_SYMBOL_GPL(crypto_unregister_kpp);
	136
1038fd78 NS	137	int kpp_register_instance(struct crypto_template *tmpl,
	138	struct kpp_instance *inst)
	139	{
	140	if (WARN_ON(!inst->free))
	141	return -EINVAL;
	142
	143	kpp_prepare_alg(&inst->alg);
	144
	145	return crypto_register_instance(tmpl, kpp_crypto_instance(inst));
	146	}
	147	EXPORT_SYMBOL_GPL(kpp_register_instance);
	148
4e5f2c40 SB	149	MODULE_LICENSE("GPL");
4e5f2c40 SB	150	MODULE_DESCRIPTION("Key-agreement Protocol Primitives");