[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 <crypto/internal/kpp.h>
#include <linux/cryptouser.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/string.h>
#include <net/netlink.h>

#include "internal.h"

static int __maybe_unused 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);
}

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 int __maybe_unused crypto_kpp_report_stat(
	struct sk_buff *skb, struct crypto_alg *alg)
{
	struct kpp_alg *kpp = __crypto_kpp_alg(alg);
	struct crypto_istat_kpp *istat;
	struct crypto_stat_kpp rkpp;

	istat = kpp_get_stat(kpp);

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

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

	rkpp.stat_setsecret_cnt = atomic64_read(&istat->setsecret_cnt);
	rkpp.stat_generate_public_key_cnt =
		atomic64_read(&istat->generate_public_key_cnt);
	rkpp.stat_compute_shared_secret_cnt =
		atomic64_read(&istat->compute_shared_secret_cnt);
	rkpp.stat_err_cnt = atomic64_read(&istat->err_cnt);

	return nla_put(skb, CRYPTOCFGA_STAT_KPP, sizeof(rkpp), &rkpp);
}

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
#if IS_ENABLED(CONFIG_CRYPTO_USER)
	.report = crypto_kpp_report,
#endif
#ifdef CONFIG_CRYPTO_STATS
	.report_stat = crypto_kpp_report_stat,
#endif
	.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_istat_kpp *istat = kpp_get_stat(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;

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

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 <[email protected]>
4e5f2c40	7	*/
e2950bf1 HX	8
	9	#include <crypto/internal/kpp.h>
	10	#include <linux/cryptouser.h>
4e5f2c40 SB	11	#include <linux/errno.h>
	12	#include <linux/kernel.h>
	13	#include <linux/module.h>
	14	#include <linux/seq_file.h>
4e5f2c40	15	#include <linux/string.h>
4e5f2c40	16	#include <net/netlink.h>
e2950bf1	17
4e5f2c40 SB	18	#include "internal.h"
4e5f2c40 SB	19
c0f9e01d HX	20	static int __maybe_unused crypto_kpp_report(
c0f9e01d HX	21	struct sk_buff skb, struct crypto_alg alg)
4e5f2c40 SB	22	{
	23	struct crypto_report_kpp rkpp;
	24
37db69e0	25	memset(&rkpp, 0, sizeof(rkpp));
4e5f2c40	26
37db69e0	27	strscpy(rkpp.type, "kpp", sizeof(rkpp.type));
4e5f2c40	28
37db69e0	29	return nla_put(skb, CRYPTOCFGA_REPORT_KPP, sizeof(rkpp), &rkpp);
4e5f2c40	30	}
4e5f2c40 SB	31
4e5f2c40 SB	32	static void crypto_kpp_show(struct seq_file m, struct crypto_alg alg)
d8c34b94	33	__maybe_unused;
4e5f2c40 SB	34
	35	static void crypto_kpp_show(struct seq_file m, struct crypto_alg alg)
	36	{
	37	seq_puts(m, "type : kpp\n");
	38	}
	39
	40	static void crypto_kpp_exit_tfm(struct crypto_tfm *tfm)
	41	{
	42	struct crypto_kpp *kpp = __crypto_kpp_tfm(tfm);
	43	struct kpp_alg *alg = crypto_kpp_alg(kpp);
	44
	45	alg->exit(kpp);
	46	}
	47
	48	static int crypto_kpp_init_tfm(struct crypto_tfm *tfm)
	49	{
	50	struct crypto_kpp *kpp = __crypto_kpp_tfm(tfm);
	51	struct kpp_alg *alg = crypto_kpp_alg(kpp);
	52
	53	if (alg->exit)
	54	kpp->base.exit = crypto_kpp_exit_tfm;
	55
	56	if (alg->init)
	57	return alg->init(kpp);
	58
	59	return 0;
	60	}
	61
1038fd78 NS	62	static void crypto_kpp_free_instance(struct crypto_instance *inst)
	63	{
	64	struct kpp_instance *kpp = kpp_instance(inst);
	65
	66	kpp->free(kpp);
	67	}
	68
e2950bf1 HX	69	static int __maybe_unused crypto_kpp_report_stat(
	70	struct sk_buff skb, struct crypto_alg alg)
	71	{
	72	struct kpp_alg *kpp = __crypto_kpp_alg(alg);
	73	struct crypto_istat_kpp *istat;
	74	struct crypto_stat_kpp rkpp;
	75
	76	istat = kpp_get_stat(kpp);
	77
	78	memset(&rkpp, 0, sizeof(rkpp));
	79
	80	strscpy(rkpp.type, "kpp", sizeof(rkpp.type));
	81
	82	rkpp.stat_setsecret_cnt = atomic64_read(&istat->setsecret_cnt);
	83	rkpp.stat_generate_public_key_cnt =
	84	atomic64_read(&istat->generate_public_key_cnt);
	85	rkpp.stat_compute_shared_secret_cnt =
	86	atomic64_read(&istat->compute_shared_secret_cnt);
	87	rkpp.stat_err_cnt = atomic64_read(&istat->err_cnt);
	88
	89	return nla_put(skb, CRYPTOCFGA_STAT_KPP, sizeof(rkpp), &rkpp);
	90	}
	91
4e5f2c40 SB	92	static const struct crypto_type crypto_kpp_type = {
	93	.extsize = crypto_alg_extsize,
	94	.init_tfm = crypto_kpp_init_tfm,
1038fd78	95	.free = crypto_kpp_free_instance,
4e5f2c40 SB	96	#ifdef CONFIG_PROC_FS
	97	.show = crypto_kpp_show,
	98	#endif
b8969a1b	99	#if IS_ENABLED(CONFIG_CRYPTO_USER)
4e5f2c40	100	.report = crypto_kpp_report,
c0f9e01d	101	#endif
e2950bf1 HX	102	#ifdef CONFIG_CRYPTO_STATS
	103	.report_stat = crypto_kpp_report_stat,
	104	#endif
4e5f2c40 SB	105	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	106	.maskset = CRYPTO_ALG_TYPE_MASK,
	107	.type = CRYPTO_ALG_TYPE_KPP,
	108	.tfmsize = offsetof(struct crypto_kpp, base),
	109	};
	110
	111	struct crypto_kpp crypto_alloc_kpp(const char alg_name, u32 type, u32 mask)
	112	{
	113	return crypto_alloc_tfm(alg_name, &crypto_kpp_type, type, mask);
	114	}
	115	EXPORT_SYMBOL_GPL(crypto_alloc_kpp);
	116
46ed5269 NS	117	int crypto_grab_kpp(struct crypto_kpp_spawn *spawn,
	118	struct crypto_instance *inst,
	119	const char *name, u32 type, u32 mask)
	120	{
	121	spawn->base.frontend = &crypto_kpp_type;
	122	return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
	123	}
	124	EXPORT_SYMBOL_GPL(crypto_grab_kpp);
	125
9e2f284e HR	126	int crypto_has_kpp(const char *alg_name, u32 type, u32 mask)
	127	{
	128	return crypto_type_has_alg(alg_name, &crypto_kpp_type, type, mask);
	129	}
	130	EXPORT_SYMBOL_GPL(crypto_has_kpp);
	131
4e5f2c40 SB	132	static void kpp_prepare_alg(struct kpp_alg *alg)
4e5f2c40 SB	133	{
e2950bf1	134	struct crypto_istat_kpp *istat = kpp_get_stat(alg);
4e5f2c40 SB	135	struct crypto_alg *base = &alg->base;
	136
	137	base->cra_type = &crypto_kpp_type;
	138	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	139	base->cra_flags \|= CRYPTO_ALG_TYPE_KPP;
e2950bf1 HX	140
	141	if (IS_ENABLED(CONFIG_CRYPTO_STATS))
	142	memset(istat, 0, sizeof(*istat));
4e5f2c40 SB	143	}
	144
	145	int crypto_register_kpp(struct kpp_alg *alg)
	146	{
	147	struct crypto_alg *base = &alg->base;
	148
	149	kpp_prepare_alg(alg);
	150	return crypto_register_alg(base);
	151	}
	152	EXPORT_SYMBOL_GPL(crypto_register_kpp);
	153
	154	void crypto_unregister_kpp(struct kpp_alg *alg)
	155	{
	156	crypto_unregister_alg(&alg->base);
	157	}
	158	EXPORT_SYMBOL_GPL(crypto_unregister_kpp);
	159
1038fd78 NS	160	int kpp_register_instance(struct crypto_template *tmpl,
	161	struct kpp_instance *inst)
	162	{
	163	if (WARN_ON(!inst->free))
	164	return -EINVAL;
	165
	166	kpp_prepare_alg(&inst->alg);
	167
	168	return crypto_register_instance(tmpl, kpp_crypto_instance(inst));
	169	}
	170	EXPORT_SYMBOL_GPL(kpp_register_instance);
	171
4e5f2c40 SB	172	MODULE_LICENSE("GPL");
4e5f2c40 SB	173	MODULE_DESCRIPTION("Key-agreement Protocol Primitives");