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

akcipher.c (4141B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * Public Key Encryption
      4 *
      5 * Copyright (c) 2015, Intel Corporation
      6 * Authors: Tadeusz Struk <tadeusz.struk@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 <linux/compiler.h>
     16#include <crypto/algapi.h>
     17#include <linux/cryptouser.h>
     18#include <net/netlink.h>
     19#include <crypto/akcipher.h>
     20#include <crypto/internal/akcipher.h>
     21#include "internal.h"
     22
     23#ifdef CONFIG_NET
     24static int crypto_akcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
     25{
     26	struct crypto_report_akcipher rakcipher;
     27
     28	memset(&rakcipher, 0, sizeof(rakcipher));
     29
     30	strscpy(rakcipher.type, "akcipher", sizeof(rakcipher.type));
     31
     32	return nla_put(skb, CRYPTOCFGA_REPORT_AKCIPHER,
     33		       sizeof(rakcipher), &rakcipher);
     34}
     35#else
     36static int crypto_akcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
     37{
     38	return -ENOSYS;
     39}
     40#endif
     41
     42static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
     43	__maybe_unused;
     44
     45static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
     46{
     47	seq_puts(m, "type         : akcipher\n");
     48}
     49
     50static void crypto_akcipher_exit_tfm(struct crypto_tfm *tfm)
     51{
     52	struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
     53	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
     54
     55	alg->exit(akcipher);
     56}
     57
     58static int crypto_akcipher_init_tfm(struct crypto_tfm *tfm)
     59{
     60	struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
     61	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
     62
     63	if (alg->exit)
     64		akcipher->base.exit = crypto_akcipher_exit_tfm;
     65
     66	if (alg->init)
     67		return alg->init(akcipher);
     68
     69	return 0;
     70}
     71
     72static void crypto_akcipher_free_instance(struct crypto_instance *inst)
     73{
     74	struct akcipher_instance *akcipher = akcipher_instance(inst);
     75
     76	akcipher->free(akcipher);
     77}
     78
     79static const struct crypto_type crypto_akcipher_type = {
     80	.extsize = crypto_alg_extsize,
     81	.init_tfm = crypto_akcipher_init_tfm,
     82	.free = crypto_akcipher_free_instance,
     83#ifdef CONFIG_PROC_FS
     84	.show = crypto_akcipher_show,
     85#endif
     86	.report = crypto_akcipher_report,
     87	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
     88	.maskset = CRYPTO_ALG_TYPE_MASK,
     89	.type = CRYPTO_ALG_TYPE_AKCIPHER,
     90	.tfmsize = offsetof(struct crypto_akcipher, base),
     91};
     92
     93int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn,
     94			 struct crypto_instance *inst,
     95			 const char *name, u32 type, u32 mask)
     96{
     97	spawn->base.frontend = &crypto_akcipher_type;
     98	return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
     99}
    100EXPORT_SYMBOL_GPL(crypto_grab_akcipher);
    101
    102struct crypto_akcipher *crypto_alloc_akcipher(const char *alg_name, u32 type,
    103					      u32 mask)
    104{
    105	return crypto_alloc_tfm(alg_name, &crypto_akcipher_type, type, mask);
    106}
    107EXPORT_SYMBOL_GPL(crypto_alloc_akcipher);
    108
    109static void akcipher_prepare_alg(struct akcipher_alg *alg)
    110{
    111	struct crypto_alg *base = &alg->base;
    112
    113	base->cra_type = &crypto_akcipher_type;
    114	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
    115	base->cra_flags |= CRYPTO_ALG_TYPE_AKCIPHER;
    116}
    117
    118static int akcipher_default_op(struct akcipher_request *req)
    119{
    120	return -ENOSYS;
    121}
    122
    123int crypto_register_akcipher(struct akcipher_alg *alg)
    124{
    125	struct crypto_alg *base = &alg->base;
    126
    127	if (!alg->sign)
    128		alg->sign = akcipher_default_op;
    129	if (!alg->verify)
    130		alg->verify = akcipher_default_op;
    131	if (!alg->encrypt)
    132		alg->encrypt = akcipher_default_op;
    133	if (!alg->decrypt)
    134		alg->decrypt = akcipher_default_op;
    135
    136	akcipher_prepare_alg(alg);
    137	return crypto_register_alg(base);
    138}
    139EXPORT_SYMBOL_GPL(crypto_register_akcipher);
    140
    141void crypto_unregister_akcipher(struct akcipher_alg *alg)
    142{
    143	crypto_unregister_alg(&alg->base);
    144}
    145EXPORT_SYMBOL_GPL(crypto_unregister_akcipher);
    146
    147int akcipher_register_instance(struct crypto_template *tmpl,
    148			       struct akcipher_instance *inst)
    149{
    150	if (WARN_ON(!inst->free))
    151		return -EINVAL;
    152	akcipher_prepare_alg(&inst->alg);
    153	return crypto_register_instance(tmpl, akcipher_crypto_instance(inst));
    154}
    155EXPORT_SYMBOL_GPL(akcipher_register_instance);
    156
    157MODULE_LICENSE("GPL");
    158MODULE_DESCRIPTION("Generic public key cipher type");