crypto/akcipher.c

   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 <crypto/internal/akcipher.h>
   9 #include <linux/cryptouser.h>
  10 #include <linux/errno.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/scatterlist.h>
  14 #include <linux/seq_file.h>
  15 #include <linux/slab.h>
  16 #include <linux/string.h>
  17 #include <net/netlink.h>
  18
  19 #include "internal.h"
  20
  21 #define CRYPTO_ALG_TYPE_AHASH_MASK      0x0000000e
  22
  23 struct crypto_akcipher_sync_data {
  24         struct crypto_akcipher *tfm;
  25         const void *src;
  26         void *dst;
  27         unsigned int slen;
  28         unsigned int dlen;
  29
  30         struct akcipher_request *req;
  31         struct crypto_wait cwait;
  32         struct scatterlist sg;
  33         u8 *buf;
  34 };
  35
  36 static int __maybe_unused crypto_akcipher_report(
  37         struct sk_buff *skb, struct crypto_alg *alg)
  38 {
  39         struct crypto_report_akcipher rakcipher;
  40
  41         memset(&rakcipher, 0, sizeof(rakcipher));
  42
  43         strscpy(rakcipher.type, "akcipher", sizeof(rakcipher.type));
  44
  45         return nla_put(skb, CRYPTOCFGA_REPORT_AKCIPHER,
  46                        sizeof(rakcipher), &rakcipher);
  47 }
  48
  49 static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
  50         __maybe_unused;
  51
  52 static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
  53 {
  54         seq_puts(m, "type         : akcipher\n");
  55 }
  56
  57 static void crypto_akcipher_exit_tfm(struct crypto_tfm *tfm)
  58 {
  59         struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
  60         struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
  61
  62         alg->exit(akcipher);
  63 }
  64
  65 static int crypto_akcipher_init_tfm(struct crypto_tfm *tfm)
  66 {
  67         struct crypto_akcipher *akcipher = __crypto_akcipher_tfm(tfm);
  68         struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
  69
  70         if (alg->exit)
  71                 akcipher->base.exit = crypto_akcipher_exit_tfm;
  72
  73         if (alg->init)
  74                 return alg->init(akcipher);
  75
  76         return 0;
  77 }
  78
  79 static void crypto_akcipher_free_instance(struct crypto_instance *inst)
  80 {
  81         struct akcipher_instance *akcipher = akcipher_instance(inst);
  82
  83         akcipher->free(akcipher);
  84 }
  85
  86 static const struct crypto_type crypto_akcipher_type = {
  87         .extsize = crypto_alg_extsize,
  88         .init_tfm = crypto_akcipher_init_tfm,
  89         .free = crypto_akcipher_free_instance,
  90 #ifdef CONFIG_PROC_FS
  91         .show = crypto_akcipher_show,
  92 #endif
  93 #if IS_ENABLED(CONFIG_CRYPTO_USER)
  94         .report = crypto_akcipher_report,
  95 #endif
  96         .maskclear = ~CRYPTO_ALG_TYPE_MASK,
  97         .maskset = CRYPTO_ALG_TYPE_AHASH_MASK,
  98         .type = CRYPTO_ALG_TYPE_AKCIPHER,
  99         .tfmsize = offsetof(struct crypto_akcipher, base),
 100 };
 101
 102 int crypto_grab_akcipher(struct crypto_akcipher_spawn *spawn,
 103                          struct crypto_instance *inst,
 104                          const char *name, u32 type, u32 mask)
 105 {
 106         spawn->base.frontend = &crypto_akcipher_type;
 107         return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
 108 }
 109 EXPORT_SYMBOL_GPL(crypto_grab_akcipher);
 110
 111 struct crypto_akcipher *crypto_alloc_akcipher(const char *alg_name, u32 type,
 112                                               u32 mask)
 113 {
 114         return crypto_alloc_tfm(alg_name, &crypto_akcipher_type, type, mask);
 115 }
 116 EXPORT_SYMBOL_GPL(crypto_alloc_akcipher);
 117
 118 static void akcipher_prepare_alg(struct akcipher_alg *alg)
 119 {
 120         struct crypto_alg *base = &alg->base;
 121
 122         base->cra_type = &crypto_akcipher_type;
 123         base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
 124         base->cra_flags |= CRYPTO_ALG_TYPE_AKCIPHER;
 125 }
 126
 127 static int akcipher_default_op(struct akcipher_request *req)
 128 {
 129         return -ENOSYS;
 130 }
 131
 132 static int akcipher_default_set_key(struct crypto_akcipher *tfm,
 133                                      const void *key, unsigned int keylen)
 134 {
 135         return -ENOSYS;
 136 }
 137
 138 int crypto_register_akcipher(struct akcipher_alg *alg)
 139 {
 140         struct crypto_alg *base = &alg->base;
 141
 142         if (!alg->encrypt)
 143                 alg->encrypt = akcipher_default_op;
 144         if (!alg->decrypt)
 145                 alg->decrypt = akcipher_default_op;
 146         if (!alg->set_priv_key)
 147                 alg->set_priv_key = akcipher_default_set_key;
 148
 149         akcipher_prepare_alg(alg);
 150         return crypto_register_alg(base);
 151 }
 152 EXPORT_SYMBOL_GPL(crypto_register_akcipher);
 153
 154 void crypto_unregister_akcipher(struct akcipher_alg *alg)
 155 {
 156         crypto_unregister_alg(&alg->base);
 157 }
 158 EXPORT_SYMBOL_GPL(crypto_unregister_akcipher);
 159
 160 int akcipher_register_instance(struct crypto_template *tmpl,
 161                                struct akcipher_instance *inst)
 162 {
 163         if (WARN_ON(!inst->free))
 164                 return -EINVAL;
 165         akcipher_prepare_alg(&inst->alg);
 166         return crypto_register_instance(tmpl, akcipher_crypto_instance(inst));
 167 }
 168 EXPORT_SYMBOL_GPL(akcipher_register_instance);
 169
 170 static int crypto_akcipher_sync_prep(struct crypto_akcipher_sync_data *data)
 171 {
 172         unsigned int reqsize = crypto_akcipher_reqsize(data->tfm);
 173         struct akcipher_request *req;
 174         struct scatterlist *sg;
 175         unsigned int mlen;
 176         unsigned int len;
 177         u8 *buf;
 178
 179         mlen = max(data->slen, data->dlen);
 180
 181         len = sizeof(*req) + reqsize + mlen;
 182         if (len < mlen)
 183                 return -EOVERFLOW;
 184
 185         req = kzalloc(len, GFP_KERNEL);
 186         if (!req)
 187                 return -ENOMEM;
 188
 189         data->req = req;
 190         akcipher_request_set_tfm(req, data->tfm);
 191
 192         buf = (u8 *)(req + 1) + reqsize;
 193         data->buf = buf;
 194         memcpy(buf, data->src, data->slen);
 195
 196         sg = &data->sg;
 197         sg_init_one(sg, buf, mlen);
 198         akcipher_request_set_crypt(req, sg, sg, data->slen, data->dlen);
 199
 200         crypto_init_wait(&data->cwait);
 201         akcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
 202                                       crypto_req_done, &data->cwait);
 203
 204         return 0;
 205 }
 206
 207 static int crypto_akcipher_sync_post(struct crypto_akcipher_sync_data *data,
 208                                      int err)
 209 {
 210         err = crypto_wait_req(err, &data->cwait);
 211         memcpy(data->dst, data->buf, data->dlen);
 212         data->dlen = data->req->dst_len;
 213         kfree_sensitive(data->req);
 214         return err;
 215 }
 216
 217 int crypto_akcipher_sync_encrypt(struct crypto_akcipher *tfm,
 218                                  const void *src, unsigned int slen,
 219                                  void *dst, unsigned int dlen)
 220 {
 221         struct crypto_akcipher_sync_data data = {
 222                 .tfm = tfm,
 223                 .src = src,
 224                 .dst = dst,
 225                 .slen = slen,
 226                 .dlen = dlen,
 227         };
 228
 229         return crypto_akcipher_sync_prep(&data) ?:
 230                crypto_akcipher_sync_post(&data,
 231                                          crypto_akcipher_encrypt(data.req));
 232 }
 233 EXPORT_SYMBOL_GPL(crypto_akcipher_sync_encrypt);
 234
 235 int crypto_akcipher_sync_decrypt(struct crypto_akcipher *tfm,
 236                                  const void *src, unsigned int slen,
 237                                  void *dst, unsigned int dlen)
 238 {
 239         struct crypto_akcipher_sync_data data = {
 240                 .tfm = tfm,
 241                 .src = src,
 242                 .dst = dst,
 243                 .slen = slen,
 244                 .dlen = dlen,
 245         };
 246
 247         return crypto_akcipher_sync_prep(&data) ?:
 248                crypto_akcipher_sync_post(&data,
 249                                          crypto_akcipher_decrypt(data.req)) ?:
 250                data.dlen;
 251 }
 252 EXPORT_SYMBOL_GPL(crypto_akcipher_sync_decrypt);
 253
 254 MODULE_LICENSE("GPL");
 255 MODULE_DESCRIPTION("Generic public key cipher type");