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         MPI p;
  21         MPI q;
  22         MPI dp;
  23         MPI dq;
  24         MPI qinv;
  25 };
  26
  27 /*
  28  * RSAEP function [RFC3447 sec 5.1.1]
  29  * c = m^e mod n;
  30  */
  31 static int _rsa_enc(const struct rsa_mpi_key *key, MPI c, MPI m)
  32 {
  33         /* (1) Validate 0 <= m < n */
  34         if (mpi_cmp_ui(m, 0) < 0 || mpi_cmp(m, key->n) >= 0)
  35                 return -EINVAL;
  36
  37         /* (2) c = m^e mod n */
  38         return mpi_powm(c, m, key->e, key->n);
  39 }
  40
  41 /*
  42  * RSADP function [RFC3447 sec 5.1.2]
  43  * m_1 = c^dP mod p;
  44  * m_2 = c^dQ mod q;
  45  * h = (m_1 - m_2) * qInv mod p;
  46  * m = m_2 + q * h;
  47  */
  48 static int _rsa_dec_crt(const struct rsa_mpi_key *key, MPI m_or_m1_or_h, MPI c)
  49 {
  50         MPI m2, m12_or_qh;
  51         int ret = -ENOMEM;
  52
  53         /* (1) Validate 0 <= c < n */
  54         if (mpi_cmp_ui(c, 0) < 0 || mpi_cmp(c, key->n) >= 0)
  55                 return -EINVAL;
  56
  57         m2 = mpi_alloc(0);
  58         m12_or_qh = mpi_alloc(0);
  59         if (!m2 || !m12_or_qh)
  60                 goto err_free_mpi;
  61
  62         /* (2i) m_1 = c^dP mod p */
  63         ret = mpi_powm(m_or_m1_or_h, c, key->dp, key->p);
  64         if (ret)
  65                 goto err_free_mpi;
  66
  67         /* (2i) m_2 = c^dQ mod q */
  68         ret = mpi_powm(m2, c, key->dq, key->q);
  69         if (ret)
  70                 goto err_free_mpi;
  71
  72         /* (2iii) h = (m_1 - m_2) * qInv mod p */
  73         mpi_sub(m12_or_qh, m_or_m1_or_h, m2);
  74         mpi_mulm(m_or_m1_or_h, m12_or_qh, key->qinv, key->p);
  75
  76         /* (2iv) m = m_2 + q * h */
  77         mpi_mul(m12_or_qh, key->q, m_or_m1_or_h);
  78         mpi_addm(m_or_m1_or_h, m2, m12_or_qh, key->n);
  79
  80         ret = 0;
  81
  82 err_free_mpi:
  83         mpi_free(m12_or_qh);
  84         mpi_free(m2);
  85         return ret;
  86 }
  87
  88 static inline struct rsa_mpi_key *rsa_get_key(struct crypto_akcipher *tfm)
  89 {
  90         return akcipher_tfm_ctx(tfm);
  91 }
  92
  93 static int rsa_enc(struct akcipher_request *req)
  94 {
  95         struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
  96         const struct rsa_mpi_key *pkey = rsa_get_key(tfm);
  97         MPI m, c = mpi_alloc(0);
  98         int ret = 0;
  99         int sign;
 100
 101         if (!c)
 102                 return -ENOMEM;
 103
 104         if (unlikely(!pkey->n || !pkey->e)) {
 105                 ret = -EINVAL;
 106                 goto err_free_c;
 107         }
 108
 109         ret = -ENOMEM;
 110         m = mpi_read_raw_from_sgl(req->src, req->src_len);
 111         if (!m)
 112                 goto err_free_c;
 113
 114         ret = _rsa_enc(pkey, c, m);
 115         if (ret)
 116                 goto err_free_m;
 117
 118         ret = mpi_write_to_sgl(c, req->dst, req->dst_len, &sign);
 119         if (ret)
 120                 goto err_free_m;
 121
 122         if (sign < 0)
 123                 ret = -EBADMSG;
 124
 125 err_free_m:
 126         mpi_free(m);
 127 err_free_c:
 128         mpi_free(c);
 129         return ret;
 130 }
 131
 132 static int rsa_dec(struct akcipher_request *req)
 133 {
 134         struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req);
 135         const struct rsa_mpi_key *pkey = rsa_get_key(tfm);
 136         MPI c, m = mpi_alloc(0);
 137         int ret = 0;
 138         int sign;
 139
 140         if (!m)
 141                 return -ENOMEM;
 142
 143         if (unlikely(!pkey->n || !pkey->d)) {
 144                 ret = -EINVAL;
 145                 goto err_free_m;
 146         }
 147
 148         ret = -ENOMEM;
 149         c = mpi_read_raw_from_sgl(req->src, req->src_len);
 150         if (!c)
 151                 goto err_free_m;
 152
 153         ret = _rsa_dec_crt(pkey, m, c);
 154         if (ret)
 155                 goto err_free_c;
 156
 157         ret = mpi_write_to_sgl(m, req->dst, req->dst_len, &sign);
 158         if (ret)
 159                 goto err_free_c;
 160
 161         if (sign < 0)
 162                 ret = -EBADMSG;
 163 err_free_c:
 164         mpi_free(c);
 165 err_free_m:
 166         mpi_free(m);
 167         return ret;
 168 }
 169
 170 static void rsa_free_mpi_key(struct rsa_mpi_key *key)
 171 {
 172         mpi_free(key->d);
 173         mpi_free(key->e);
 174         mpi_free(key->n);
 175         mpi_free(key->p);
 176         mpi_free(key->q);
 177         mpi_free(key->dp);
 178         mpi_free(key->dq);
 179         mpi_free(key->qinv);
 180         key->d = NULL;
 181         key->e = NULL;
 182         key->n = NULL;
 183         key->p = NULL;
 184         key->q = NULL;
 185         key->dp = NULL;
 186         key->dq = NULL;
 187         key->qinv = NULL;
 188 }
 189
 190 static int rsa_check_key_length(unsigned int len)
 191 {
 192         switch (len) {
 193         case 512:
 194         case 1024:
 195         case 1536:
 196                 if (fips_enabled)
 197                         return -EINVAL;
 198                 fallthrough;
 199         case 2048:
 200         case 3072:
 201         case 4096:
 202                 return 0;
 203         }
 204
 205         return -EINVAL;
 206 }
 207
 208 static int rsa_set_pub_key(struct crypto_akcipher *tfm, const void *key,
 209                            unsigned int keylen)
 210 {
 211         struct rsa_mpi_key *mpi_key = akcipher_tfm_ctx(tfm);
 212         struct rsa_key raw_key = {0};
 213         int ret;
 214
 215         /* Free the old MPI key if any */
 216         rsa_free_mpi_key(mpi_key);
 217
 218         ret = rsa_parse_pub_key(&raw_key, key, keylen);
 219         if (ret)
 220                 return ret;
 221
 222         mpi_key->e = mpi_read_raw_data(raw_key.e, raw_key.e_sz);
 223         if (!mpi_key->e)
 224                 goto err;
 225
 226         mpi_key->n = mpi_read_raw_data(raw_key.n, raw_key.n_sz);
 227         if (!mpi_key->n)
 228                 goto err;
 229
 230         if (rsa_check_key_length(mpi_get_size(mpi_key->n) << 3)) {
 231                 rsa_free_mpi_key(mpi_key);
 232                 return -EINVAL;
 233         }
 234
 235         return 0;
 236
 237 err:
 238         rsa_free_mpi_key(mpi_key);
 239         return -ENOMEM;
 240 }
 241
 242 static int rsa_set_priv_key(struct crypto_akcipher *tfm, const void *key,
 243                             unsigned int keylen)
 244 {
 245         struct rsa_mpi_key *mpi_key = akcipher_tfm_ctx(tfm);
 246         struct rsa_key raw_key = {0};
 247         int ret;
 248
 249         /* Free the old MPI key if any */
 250         rsa_free_mpi_key(mpi_key);
 251
 252         ret = rsa_parse_priv_key(&raw_key, key, keylen);
 253         if (ret)
 254                 return ret;
 255
 256         mpi_key->d = mpi_read_raw_data(raw_key.d, raw_key.d_sz);
 257         if (!mpi_key->d)
 258                 goto err;
 259
 260         mpi_key->e = mpi_read_raw_data(raw_key.e, raw_key.e_sz);
 261         if (!mpi_key->e)
 262                 goto err;
 263
 264         mpi_key->n = mpi_read_raw_data(raw_key.n, raw_key.n_sz);
 265         if (!mpi_key->n)
 266                 goto err;
 267
 268         mpi_key->p = mpi_read_raw_data(raw_key.p, raw_key.p_sz);
 269         if (!mpi_key->p)
 270                 goto err;
 271
 272         mpi_key->q = mpi_read_raw_data(raw_key.q, raw_key.q_sz);
 273         if (!mpi_key->q)
 274                 goto err;
 275
 276         mpi_key->dp = mpi_read_raw_data(raw_key.dp, raw_key.dp_sz);
 277         if (!mpi_key->dp)
 278                 goto err;
 279
 280         mpi_key->dq = mpi_read_raw_data(raw_key.dq, raw_key.dq_sz);
 281         if (!mpi_key->dq)
 282                 goto err;
 283
 284         mpi_key->qinv = mpi_read_raw_data(raw_key.qinv, raw_key.qinv_sz);
 285         if (!mpi_key->qinv)
 286                 goto err;
 287
 288         if (rsa_check_key_length(mpi_get_size(mpi_key->n) << 3)) {
 289                 rsa_free_mpi_key(mpi_key);
 290                 return -EINVAL;
 291         }
 292
 293         return 0;
 294
 295 err:
 296         rsa_free_mpi_key(mpi_key);
 297         return -ENOMEM;
 298 }
 299
 300 static unsigned int rsa_max_size(struct crypto_akcipher *tfm)
 301 {
 302         struct rsa_mpi_key *pkey = akcipher_tfm_ctx(tfm);
 303
 304         return mpi_get_size(pkey->n);
 305 }
 306
 307 static void rsa_exit_tfm(struct crypto_akcipher *tfm)
 308 {
 309         struct rsa_mpi_key *pkey = akcipher_tfm_ctx(tfm);
 310
 311         rsa_free_mpi_key(pkey);
 312 }
 313
 314 static struct akcipher_alg rsa = {
 315         .encrypt = rsa_enc,
 316         .decrypt = rsa_dec,
 317         .set_priv_key = rsa_set_priv_key,
 318         .set_pub_key = rsa_set_pub_key,
 319         .max_size = rsa_max_size,
 320         .exit = rsa_exit_tfm,
 321         .base = {
 322                 .cra_name = "rsa",
 323                 .cra_driver_name = "rsa-generic",
 324                 .cra_priority = 100,
 325                 .cra_module = THIS_MODULE,
 326                 .cra_ctxsize = sizeof(struct rsa_mpi_key),
 327         },
 328 };
 329
 330 static int __init rsa_init(void)
 331 {
 332         int err;
 333
 334         err = crypto_register_akcipher(&rsa);
 335         if (err)
 336                 return err;
 337
 338         err = crypto_register_template(&rsa_pkcs1pad_tmpl);
 339         if (err) {
 340                 crypto_unregister_akcipher(&rsa);
 341                 return err;
 342         }
 343
 344         return 0;
 345 }
 346
 347 static void __exit rsa_exit(void)
 348 {
 349         crypto_unregister_template(&rsa_pkcs1pad_tmpl);
 350         crypto_unregister_akcipher(&rsa);
 351 }
 352
 353 subsys_initcall(rsa_init);
 354 module_exit(rsa_exit);
 355 MODULE_ALIAS_CRYPTO("rsa");
 356 MODULE_LICENSE("GPL");
 357 MODULE_DESCRIPTION("RSA generic algorithm");