cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

kpp.c (3487B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * Key-agreement Protocol Primitives (KPP)
      4 *
      5 * Copyright (c) 2016, Intel Corporation
      6 * Authors: Salvatore Benedetto <salvatore.benedetto@intel.com>
      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>
     17#include <linux/compiler.h>
     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
     24static int crypto_kpp_report(struct sk_buff *skb, struct crypto_alg *alg)
     25{
     26	struct crypto_report_kpp rkpp;
     27
     28	memset(&rkpp, 0, sizeof(rkpp));
     29
     30	strscpy(rkpp.type, "kpp", sizeof(rkpp.type));
     31
     32	return nla_put(skb, CRYPTOCFGA_REPORT_KPP, sizeof(rkpp), &rkpp);
     33}
     34#else
     35static int crypto_kpp_report(struct sk_buff *skb, struct crypto_alg *alg)
     36{
     37	return -ENOSYS;
     38}
     39#endif
     40
     41static void crypto_kpp_show(struct seq_file *m, struct crypto_alg *alg)
     42	__maybe_unused;
     43
     44static void crypto_kpp_show(struct seq_file *m, struct crypto_alg *alg)
     45{
     46	seq_puts(m, "type         : kpp\n");
     47}
     48
     49static 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
     57static 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
     71static 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
     78static const struct crypto_type crypto_kpp_type = {
     79	.extsize = crypto_alg_extsize,
     80	.init_tfm = crypto_kpp_init_tfm,
     81	.free = crypto_kpp_free_instance,
     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
     92struct 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}
     96EXPORT_SYMBOL_GPL(crypto_alloc_kpp);
     97
     98int 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}
    105EXPORT_SYMBOL_GPL(crypto_grab_kpp);
    106
    107static void kpp_prepare_alg(struct kpp_alg *alg)
    108{
    109	struct crypto_alg *base = &alg->base;
    110
    111	base->cra_type = &crypto_kpp_type;
    112	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
    113	base->cra_flags |= CRYPTO_ALG_TYPE_KPP;
    114}
    115
    116int crypto_register_kpp(struct kpp_alg *alg)
    117{
    118	struct crypto_alg *base = &alg->base;
    119
    120	kpp_prepare_alg(alg);
    121	return crypto_register_alg(base);
    122}
    123EXPORT_SYMBOL_GPL(crypto_register_kpp);
    124
    125void crypto_unregister_kpp(struct kpp_alg *alg)
    126{
    127	crypto_unregister_alg(&alg->base);
    128}
    129EXPORT_SYMBOL_GPL(crypto_unregister_kpp);
    130
    131int kpp_register_instance(struct crypto_template *tmpl,
    132			  struct kpp_instance *inst)
    133{
    134	if (WARN_ON(!inst->free))
    135		return -EINVAL;
    136
    137	kpp_prepare_alg(&inst->alg);
    138
    139	return crypto_register_instance(tmpl, kpp_crypto_instance(inst));
    140}
    141EXPORT_SYMBOL_GPL(kpp_register_instance);
    142
    143MODULE_LICENSE("GPL");
    144MODULE_DESCRIPTION("Key-agreement Protocol Primitives");