crypto/sig.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Public Key Signature Algorithm
   4  *
   5  * Copyright (c) 2023 Herbert Xu <herbert@gondor.apana.org.au>
   6  */
   7
   8 #include <crypto/internal/sig.h>
   9 #include <linux/cryptouser.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/seq_file.h>
  13 #include <linux/string.h>
  14 #include <net/netlink.h>
  15
  16 #include "internal.h"
  17
  18 static void crypto_sig_exit_tfm(struct crypto_tfm *tfm)
  19 {
  20         struct crypto_sig *sig = __crypto_sig_tfm(tfm);
  21         struct sig_alg *alg = crypto_sig_alg(sig);
  22
  23         alg->exit(sig);
  24 }
  25
  26 static int crypto_sig_init_tfm(struct crypto_tfm *tfm)
  27 {
  28         struct crypto_sig *sig = __crypto_sig_tfm(tfm);
  29         struct sig_alg *alg = crypto_sig_alg(sig);
  30
  31         if (alg->exit)
  32                 sig->base.exit = crypto_sig_exit_tfm;
  33
  34         if (alg->init)
  35                 return alg->init(sig);
  36
  37         return 0;
  38 }
  39
  40 static void crypto_sig_free_instance(struct crypto_instance *inst)
  41 {
  42         struct sig_instance *sig = sig_instance(inst);
  43
  44         sig->free(sig);
  45 }
  46
  47 static void __maybe_unused crypto_sig_show(struct seq_file *m,
  48                                            struct crypto_alg *alg)
  49 {
  50         seq_puts(m, "type         : sig\n");
  51 }
  52
  53 static int __maybe_unused crypto_sig_report(struct sk_buff *skb,
  54                                             struct crypto_alg *alg)
  55 {
  56         struct crypto_report_sig rsig = {};
  57
  58         strscpy(rsig.type, "sig", sizeof(rsig.type));
  59
  60         return nla_put(skb, CRYPTOCFGA_REPORT_SIG, sizeof(rsig), &rsig);
  61 }
  62
  63 static const struct crypto_type crypto_sig_type = {
  64         .extsize = crypto_alg_extsize,
  65         .init_tfm = crypto_sig_init_tfm,
  66         .free = crypto_sig_free_instance,
  67 #ifdef CONFIG_PROC_FS
  68         .show = crypto_sig_show,
  69 #endif
  70 #if IS_ENABLED(CONFIG_CRYPTO_USER)
  71         .report = crypto_sig_report,
  72 #endif
  73         .maskclear = ~CRYPTO_ALG_TYPE_MASK,
  74         .maskset = CRYPTO_ALG_TYPE_MASK,
  75         .type = CRYPTO_ALG_TYPE_SIG,
  76         .tfmsize = offsetof(struct crypto_sig, base),
  77 };
  78
  79 struct crypto_sig *crypto_alloc_sig(const char *alg_name, u32 type, u32 mask)
  80 {
  81         return crypto_alloc_tfm(alg_name, &crypto_sig_type, type, mask);
  82 }
  83 EXPORT_SYMBOL_GPL(crypto_alloc_sig);
  84
  85 static int sig_default_sign(struct crypto_sig *tfm,
  86                             const void *src, unsigned int slen,
  87                             void *dst, unsigned int dlen)
  88 {
  89         return -ENOSYS;
  90 }
  91
  92 static int sig_default_verify(struct crypto_sig *tfm,
  93                               const void *src, unsigned int slen,
  94                               const void *dst, unsigned int dlen)
  95 {
  96         return -ENOSYS;
  97 }
  98
  99 static int sig_default_set_key(struct crypto_sig *tfm,
 100                                const void *key, unsigned int keylen)
 101 {
 102         return -ENOSYS;
 103 }
 104
 105 static int sig_prepare_alg(struct sig_alg *alg)
 106 {
 107         struct crypto_alg *base = &alg->base;
 108
 109         if (!alg->sign)
 110                 alg->sign = sig_default_sign;
 111         if (!alg->verify)
 112                 alg->verify = sig_default_verify;
 113         if (!alg->set_priv_key)
 114                 alg->set_priv_key = sig_default_set_key;
 115         if (!alg->set_pub_key)
 116                 return -EINVAL;
 117         if (!alg->key_size)
 118                 return -EINVAL;
 119         if (!alg->max_size)
 120                 alg->max_size = alg->key_size;
 121         if (!alg->digest_size)
 122                 alg->digest_size = alg->key_size;
 123
 124         base->cra_type = &crypto_sig_type;
 125         base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
 126         base->cra_flags |= CRYPTO_ALG_TYPE_SIG;
 127
 128         return 0;
 129 }
 130
 131 int crypto_register_sig(struct sig_alg *alg)
 132 {
 133         struct crypto_alg *base = &alg->base;
 134         int err;
 135
 136         err = sig_prepare_alg(alg);
 137         if (err)
 138                 return err;
 139
 140         return crypto_register_alg(base);
 141 }
 142 EXPORT_SYMBOL_GPL(crypto_register_sig);
 143
 144 void crypto_unregister_sig(struct sig_alg *alg)
 145 {
 146         crypto_unregister_alg(&alg->base);
 147 }
 148 EXPORT_SYMBOL_GPL(crypto_unregister_sig);
 149
 150 int sig_register_instance(struct crypto_template *tmpl,
 151                           struct sig_instance *inst)
 152 {
 153         int err;
 154
 155         if (WARN_ON(!inst->free))
 156                 return -EINVAL;
 157
 158         err = sig_prepare_alg(&inst->alg);
 159         if (err)
 160                 return err;
 161
 162         return crypto_register_instance(tmpl, sig_crypto_instance(inst));
 163 }
 164 EXPORT_SYMBOL_GPL(sig_register_instance);
 165
 166 int crypto_grab_sig(struct crypto_sig_spawn *spawn,
 167                     struct crypto_instance *inst,
 168                     const char *name, u32 type, u32 mask)
 169 {
 170         spawn->base.frontend = &crypto_sig_type;
 171         return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
 172 }
 173 EXPORT_SYMBOL_GPL(crypto_grab_sig);
 174
 175 MODULE_LICENSE("GPL");
 176 MODULE_DESCRIPTION("Public Key Signature Algorithms");