[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 <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 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
	.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	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
4e5f2c40 SB	69	static const struct crypto_type crypto_kpp_type = {
	70	.extsize = crypto_alg_extsize,
	71	.init_tfm = crypto_kpp_init_tfm,
1038fd78	72	.free = crypto_kpp_free_instance,
4e5f2c40 SB	73	#ifdef CONFIG_PROC_FS
	74	.show = crypto_kpp_show,
	75	#endif
b8969a1b	76	#if IS_ENABLED(CONFIG_CRYPTO_USER)
4e5f2c40	77	.report = crypto_kpp_report,
e2950bf1	78	#endif
4e5f2c40 SB	79	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	80	.maskset = CRYPTO_ALG_TYPE_MASK,
	81	.type = CRYPTO_ALG_TYPE_KPP,
	82	.tfmsize = offsetof(struct crypto_kpp, base),
	83	};
	84
	85	struct crypto_kpp crypto_alloc_kpp(const char alg_name, u32 type, u32 mask)
	86	{
	87	return crypto_alloc_tfm(alg_name, &crypto_kpp_type, type, mask);
	88	}
	89	EXPORT_SYMBOL_GPL(crypto_alloc_kpp);
	90
46ed5269 NS	91	int crypto_grab_kpp(struct crypto_kpp_spawn *spawn,
	92	struct crypto_instance *inst,
	93	const char *name, u32 type, u32 mask)
	94	{
	95	spawn->base.frontend = &crypto_kpp_type;
	96	return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
	97	}
	98	EXPORT_SYMBOL_GPL(crypto_grab_kpp);
	99
9e2f284e HR	100	int crypto_has_kpp(const char *alg_name, u32 type, u32 mask)
	101	{
	102	return crypto_type_has_alg(alg_name, &crypto_kpp_type, type, mask);
	103	}
	104	EXPORT_SYMBOL_GPL(crypto_has_kpp);
	105
4e5f2c40 SB	106	static void kpp_prepare_alg(struct kpp_alg *alg)
	107	{
	108	struct crypto_alg *base = &alg->base;
	109
	110	base->cra_type = &crypto_kpp_type;
	111	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	112	base->cra_flags \|= CRYPTO_ALG_TYPE_KPP;
	113	}
	114
	115	int crypto_register_kpp(struct kpp_alg *alg)
	116	{
	117	struct crypto_alg *base = &alg->base;
	118
	119	kpp_prepare_alg(alg);
	120	return crypto_register_alg(base);
	121	}
	122	EXPORT_SYMBOL_GPL(crypto_register_kpp);
	123
	124	void crypto_unregister_kpp(struct kpp_alg *alg)
	125	{
	126	crypto_unregister_alg(&alg->base);
	127	}
	128	EXPORT_SYMBOL_GPL(crypto_unregister_kpp);
	129
1038fd78 NS	130	int kpp_register_instance(struct crypto_template *tmpl,
	131	struct kpp_instance *inst)
	132	{
	133	if (WARN_ON(!inst->free))
	134	return -EINVAL;
	135
	136	kpp_prepare_alg(&inst->alg);
	137
	138	return crypto_register_instance(tmpl, kpp_crypto_instance(inst));
	139	}
	140	EXPORT_SYMBOL_GPL(kpp_register_instance);
	141
4e5f2c40 SB	142	MODULE_LICENSE("GPL");
4e5f2c40 SB	143	MODULE_DESCRIPTION("Key-agreement Protocol Primitives");