crypto/rsa.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* RSA asymmetric public-key algorithm [RFC3447]
   3  *
   4  * Copyright (c) 2015, Intel Corporation
   5  * Authors: Tadeusz Struk <tadeusz.struk@intel.com>
   6  */
   7
   8 #include <linux/fips.h>
   9 #include <linux/module.h>
  10 #include <linux/mpi.h>
  11 #include <crypto/internal/rsa.h>
  12 #include <crypto/internal/akcipher.h>
  13 #include <crypto/akcipher.h>
  14 #include <crypto/algapi.h>
  15
  16 struct rsa_mpi_key {
  17         MPI n;
  18         MPI e;
  19         MPI d;
  20 };
  21
  22 /*
  23  * RSAEP function [RFC3447 sec 5.1.1]
  24  * c = m^e mod n;
  25  */
  26 static int _rsa_enc(const struct rsa_mpi_key *key, MPI c, MPI m)
  27 {
  28         /* (1) Validate 0 <= m < n */
  29         if (mpi_cmp_ui(m, 0) < 0 || mpi_cmp(m, key->n) >= 0)
  30                 return -EINVAL;
  31
  32         /* (2) c = m^e mod n */
  33         return mpi_powm(c, m, key->e, key->n);
  34 }
  35
  36 /*
  37  * RSADP function [RFC3447 sec 5.1.2]
  38  * m = c^d mod n;
  39  */
  40 static int _rsa_dec(const struct rsa_mpi_key *key, MPI m, MPI c)
  41 {
  42         /* (1) Validate 0 <= c < n */
  43         if (mpi_cmp_ui(c, 0) < 0 || mpi_cmp(c, key->n) >= 0)
  44                 return -EINVAL;
  45
  46         /* (2) m = c^d mod n */
  47         return mpi_powm(m, c, key->d, key->n);
  48 }
  49
  50 static inline struct rsa_mpi_key *rsa_get_key(struct crypto_akcipher *tfm)
  51 {
  52         return akcipher_tfm_ctx(tfm);
  53 }
  54
  55 static int rsa_enc(struct akcipher_request *req)
  56 {
  57         struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
  58         const struct rsa_mpi_key *pkey = rsa_get_key(tfm);
  59         MPI m, c = mpi_alloc(0);
  60         int ret = 0;
  61         int sign;
  62
  63         if (!c)
  64                 return -ENOMEM;
  65
  66         if (unlikely(!pkey->n || !pkey->e)) {
  67                 ret = -EINVAL;
  68                 goto err_free_c;
  69         }
  70
  71         ret = -ENOMEM;
  72         m = mpi_read_raw_from_sgl(req->src, req->src_len);
  73         if (!m)
  74                 goto err_free_c;
  75
  76         ret = _rsa_enc(pkey, c, m);
  77         if (ret)
  78                 goto err_free_m;
  79
  80         ret = mpi_write_to_sgl(c, req->dst, req->dst_len, &sign);
  81         if (ret)
  82                 goto err_free_m;
  83
  84         if (sign < 0)
  85                 ret = -EBADMSG;
  86
  87 err_free_m:
  88         mpi_free(m);
  89 err_free_c:
  90         mpi_free(c);
  91         return ret;
  92 }
  93
  94 static int rsa_dec(struct akcipher_request *req)
  95 {
  96         struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
  97         const struct rsa_mpi_key *pkey = rsa_get_key(tfm);
  98         MPI c, m = mpi_alloc(0);
  99         int ret = 0;
 100         int sign;
 101
 102         if (!m)
 103                 return -ENOMEM;
 104
 105         if (unlikely(!pkey->n || !pkey->d)) {
 106                 ret = -EINVAL;
 107                 goto err_free_m;
 108         }
 109
 110         ret = -ENOMEM;
 111         c = mpi_read_raw_from_sgl(req->src, req->src_len);
 112         if (!c)
 113                 goto err_free_m;
 114
 115         ret = _rsa_dec(pkey, m, c);
 116         if (ret)
 117                 goto err_free_c;
 118
 119         ret = mpi_write_to_sgl(m, req->dst, req->dst_len, &sign);
 120         if (ret)
 121                 goto err_free_c;
 122
 123         if (sign < 0)
 124                 ret = -EBADMSG;
 125 err_free_c:
 126         mpi_free(c);
 127 err_free_m:
 128         mpi_free(m);
 129         return ret;
 130 }
 131
 132 static void rsa_free_mpi_key(struct rsa_mpi_key *key)
 133 {
 134         mpi_free(key->d);
 135         mpi_free(key->e);
 136         mpi_free(key->n);
 137         key->d = NULL;
 138         key->e = NULL;
 139         key->n = NULL;
 140 }
 141
 142 static int rsa_check_key_length(unsigned int len)
 143 {
 144         switch (len) {
 145         case 512:
 146         case 1024:
 147         case 1536:
 148                 if (fips_enabled)
 149                         return -EINVAL;
 150                 fallthrough;
 151         case 2048:
 152         case 3072:
 153         case 4096:
 154                 return 0;
 155         }
 156
 157         return -EINVAL;
 158 }
 159
 160 static int rsa_set_pub_key(struct crypto_akcipher *tfm, const void *key,
 161                            unsigned int keylen)
 162 {
 163         struct rsa_mpi_key *mpi_key = akcipher_tfm_ctx(tfm);
 164         struct rsa_key raw_key = {0};
 165         int ret;
 166
 167         /* Free the old MPI key if any */
 168         rsa_free_mpi_key(mpi_key);
 169
 170         ret = rsa_parse_pub_key(&raw_key, key, keylen);
 171         if (ret)
 172                 return ret;
 173
 174         mpi_key->e = mpi_read_raw_data(raw_key.e, raw_key.e_sz);
 175         if (!mpi_key->e)
 176                 goto err;
 177
 178         mpi_key->n = mpi_read_raw_data(raw_key.n, raw_key.n_sz);
 179         if (!mpi_key->n)
 180                 goto err;
 181
 182         if (rsa_check_key_length(mpi_get_size(mpi_key->n) << 3)) {
 183                 rsa_free_mpi_key(mpi_key);
 184                 return -EINVAL;
 185         }
 186
 187         return 0;
 188
 189 err:
 190         rsa_free_mpi_key(mpi_key);
 191         return -ENOMEM;
 192 }
 193
 194 static int rsa_set_priv_key(struct crypto_akcipher *tfm, const void *key,
 195                             unsigned int keylen)
 196 {
 197         struct rsa_mpi_key *mpi_key = akcipher_tfm_ctx(tfm);
 198         struct rsa_key raw_key = {0};
 199         int ret;
 200
 201         /* Free the old MPI key if any */
 202         rsa_free_mpi_key(mpi_key);
 203
 204         ret = rsa_parse_priv_key(&raw_key, key, keylen);
 205         if (ret)
 206                 return ret;
 207
 208         mpi_key->d = mpi_read_raw_data(raw_key.d, raw_key.d_sz);
 209         if (!mpi_key->d)
 210                 goto err;
 211
 212         mpi_key->e = mpi_read_raw_data(raw_key.e, raw_key.e_sz);
 213         if (!mpi_key->e)
 214                 goto err;
 215
 216         mpi_key->n = mpi_read_raw_data(raw_key.n, raw_key.n_sz);
 217         if (!mpi_key->n)
 218                 goto err;
 219
 220         if (rsa_check_key_length(mpi_get_size(mpi_key->n) << 3)) {
 221                 rsa_free_mpi_key(mpi_key);
 222                 return -EINVAL;
 223         }
 224
 225         return 0;
 226
 227 err:
 228         rsa_free_mpi_key(mpi_key);
 229         return -ENOMEM;
 230 }
 231
 232 static unsigned int rsa_max_size(struct crypto_akcipher *tfm)
 233 {
 234         struct rsa_mpi_key *pkey = akcipher_tfm_ctx(tfm);
 235
 236         return mpi_get_size(pkey->n);
 237 }
 238
 239 static void rsa_exit_tfm(struct crypto_akcipher *tfm)
 240 {
 241         struct rsa_mpi_key *pkey = akcipher_tfm_ctx(tfm);
 242
 243         rsa_free_mpi_key(pkey);
 244 }
 245
 246 static struct akcipher_alg rsa = {
 247         .encrypt = rsa_enc,
 248         .decrypt = rsa_dec,
 249         .set_priv_key = rsa_set_priv_key,
 250         .set_pub_key = rsa_set_pub_key,
 251         .max_size = rsa_max_size,
 252         .exit = rsa_exit_tfm,
 253         .base = {
 254                 .cra_name = "rsa",
 255                 .cra_driver_name = "rsa-generic",
 256                 .cra_priority = 100,
 257                 .cra_module = THIS_MODULE,
 258                 .cra_ctxsize = sizeof(struct rsa_mpi_key),
 259         },
 260 };
 261
 262 static int rsa_init(void)
 263 {
 264         int err;
 265
 266         err = crypto_register_akcipher(&rsa);
 267         if (err)
 268                 return err;
 269
 270         err = crypto_register_template(&rsa_pkcs1pad_tmpl);
 271         if (err) {
 272                 crypto_unregister_akcipher(&rsa);
 273                 return err;
 274         }
 275
 276         return 0;
 277 }
 278
 279 static void rsa_exit(void)
 280 {
 281         crypto_unregister_template(&rsa_pkcs1pad_tmpl);
 282         crypto_unregister_akcipher(&rsa);
 283 }
 284
 285 subsys_initcall(rsa_init);
 286 module_exit(rsa_exit);
 287 MODULE_ALIAS_CRYPTO("rsa");
 288 MODULE_LICENSE("GPL");
 289 MODULE_DESCRIPTION("RSA generic algorithm");