[linux.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 <[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 <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 const struct crypto_type crypto_kpp_type = {
	.extsize = crypto_alg_extsize,
	.init_tfm = crypto_kpp_init_tfm,
#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);

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

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 <[email protected]>
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
	71	static const struct crypto_type crypto_kpp_type = {
	72	.extsize = crypto_alg_extsize,
	73	.init_tfm = crypto_kpp_init_tfm,
	74	#ifdef CONFIG_PROC_FS
	75	.show = crypto_kpp_show,
	76	#endif
	77	.report = crypto_kpp_report,
	78	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	79	.maskset = CRYPTO_ALG_TYPE_MASK,
	80	.type = CRYPTO_ALG_TYPE_KPP,
	81	.tfmsize = offsetof(struct crypto_kpp, base),
	82	};
	83
	84	struct crypto_kpp crypto_alloc_kpp(const char alg_name, u32 type, u32 mask)
	85	{
	86	return crypto_alloc_tfm(alg_name, &crypto_kpp_type, type, mask);
	87	}
	88	EXPORT_SYMBOL_GPL(crypto_alloc_kpp);
	89
	90	static void kpp_prepare_alg(struct kpp_alg *alg)
	91	{
	92	struct crypto_alg *base = &alg->base;
	93
	94	base->cra_type = &crypto_kpp_type;
	95	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	96	base->cra_flags \|= CRYPTO_ALG_TYPE_KPP;
	97	}
	98
	99	int crypto_register_kpp(struct kpp_alg *alg)
	100	{
	101	struct crypto_alg *base = &alg->base;
	102
	103	kpp_prepare_alg(alg);
	104	return crypto_register_alg(base);
	105	}
	106	EXPORT_SYMBOL_GPL(crypto_register_kpp);
107
108	void crypto_unregister_kpp(struct kpp_alg *alg)
109	{
110	crypto_unregister_alg(&alg->base);
111	}
112	EXPORT_SYMBOL_GPL(crypto_unregister_kpp);
113
114	MODULE_LICENSE("GPL");
115	MODULE_DESCRIPTION("Key-agreement Protocol Primitives");