crypto/rsa/rsa_lib.c

   1 /*
   2  * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * RSA low level APIs are deprecated for public use, but still ok for
  12  * internal use.
  13  */
  14 #include "internal/deprecated.h"
  15
  16 #include <openssl/crypto.h>
  17 #include <openssl/core_names.h>
  18 #ifndef FIPS_MODULE
  19 # include <openssl/engine.h>
  20 #endif
  21 #include <openssl/evp.h>
  22 #include <openssl/param_build.h>
  23 #include "internal/cryptlib.h"
  24 #include "internal/refcount.h"
  25 #include "crypto/bn.h"
  26 #include "crypto/evp.h"
  27 #include "crypto/rsa.h"
  28 #include "crypto/security_bits.h"
  29 #include "rsa_local.h"
  30
  31 static RSA *rsa_new_intern(ENGINE *engine, OSSL_LIB_CTX *libctx);
  32
  33 #ifndef FIPS_MODULE
  34 RSA *RSA_new(void)
  35 {
  36     return rsa_new_intern(NULL, NULL);
  37 }
  38
  39 const RSA_METHOD *RSA_get_method(const RSA *rsa)
  40 {
  41     return rsa->meth;
  42 }
  43
  44 int RSA_set_method(RSA *rsa, const RSA_METHOD *meth)
  45 {
  46     /*
  47      * NB: The caller is specifically setting a method, so it's not up to us
  48      * to deal with which ENGINE it comes from.
  49      */
  50     const RSA_METHOD *mtmp;
  51     mtmp = rsa->meth;
  52     if (mtmp->finish)
  53         mtmp->finish(rsa);
  54 #ifndef OPENSSL_NO_ENGINE
  55     ENGINE_finish(rsa->engine);
  56     rsa->engine = NULL;
  57 #endif
  58     rsa->meth = meth;
  59     if (meth->init)
  60         meth->init(rsa);
  61     return 1;
  62 }
  63
  64 RSA *RSA_new_method(ENGINE *engine)
  65 {
  66     return rsa_new_intern(engine, NULL);
  67 }
  68 #endif
  69
  70 RSA *ossl_rsa_new_with_ctx(OSSL_LIB_CTX *libctx)
  71 {
  72     return rsa_new_intern(NULL, libctx);
  73 }
  74
  75 static RSA *rsa_new_intern(ENGINE *engine, OSSL_LIB_CTX *libctx)
  76 {
  77     RSA *ret = OPENSSL_zalloc(sizeof(*ret));
  78
  79     if (ret == NULL)
  80         return NULL;
  81
  82     ret->lock = CRYPTO_THREAD_lock_new();
  83     if (ret->lock == NULL) {
  84         ERR_raise(ERR_LIB_RSA, ERR_R_CRYPTO_LIB);
  85         OPENSSL_free(ret);
  86         return NULL;
  87     }
  88
  89     if (!CRYPTO_NEW_REF(&ret->references, 1)) {
  90         CRYPTO_THREAD_lock_free(ret->lock);
  91         OPENSSL_free(ret);
  92         return NULL;
  93     }
  94
  95     ret->libctx = libctx;
  96     ret->meth = RSA_get_default_method();
  97 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
  98     ret->flags = ret->meth->flags & ~RSA_FLAG_NON_FIPS_ALLOW;
  99     if (engine) {
 100         if (!ENGINE_init(engine)) {
 101             ERR_raise(ERR_LIB_RSA, ERR_R_ENGINE_LIB);
 102             goto err;
 103         }
 104         ret->engine = engine;
 105     } else {
 106         ret->engine = ENGINE_get_default_RSA();
 107     }
 108     if (ret->engine) {
 109         ret->meth = ENGINE_get_RSA(ret->engine);
 110         if (ret->meth == NULL) {
 111             ERR_raise(ERR_LIB_RSA, ERR_R_ENGINE_LIB);
 112             goto err;
 113         }
 114     }
 115 #endif
 116
 117     ret->flags = ret->meth->flags & ~RSA_FLAG_NON_FIPS_ALLOW;
 118 #ifndef FIPS_MODULE
 119     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data)) {
 120         goto err;
 121     }
 122 #endif
 123
 124     if ((ret->meth->init != NULL) && !ret->meth->init(ret)) {
 125         ERR_raise(ERR_LIB_RSA, ERR_R_INIT_FAIL);
 126         goto err;
 127     }
 128
 129     return ret;
 130
 131  err:
 132     RSA_free(ret);
 133     return NULL;
 134 }
 135
 136 void RSA_free(RSA *r)
 137 {
 138     int i;
 139
 140     if (r == NULL)
 141         return;
 142
 143     CRYPTO_DOWN_REF(&r->references, &i);
 144     REF_PRINT_COUNT("RSA", r);
 145     if (i > 0)
 146         return;
 147     REF_ASSERT_ISNT(i < 0);
 148
 149     if (r->meth != NULL && r->meth->finish != NULL)
 150         r->meth->finish(r);
 151 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 152     ENGINE_finish(r->engine);
 153 #endif
 154
 155 #ifndef FIPS_MODULE
 156     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, r, &r->ex_data);
 157 #endif
 158
 159     CRYPTO_THREAD_lock_free(r->lock);
 160     CRYPTO_FREE_REF(&r->references);
 161
 162     BN_free(r->n);
 163     BN_free(r->e);
 164     BN_clear_free(r->d);
 165     BN_clear_free(r->p);
 166     BN_clear_free(r->q);
 167     BN_clear_free(r->dmp1);
 168     BN_clear_free(r->dmq1);
 169     BN_clear_free(r->iqmp);
 170
 171 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
 172     ossl_rsa_acvp_test_free(r->acvp_test);
 173 #endif
 174
 175 #ifndef FIPS_MODULE
 176     RSA_PSS_PARAMS_free(r->pss);
 177     sk_RSA_PRIME_INFO_pop_free(r->prime_infos, ossl_rsa_multip_info_free);
 178 #endif
 179     BN_BLINDING_free(r->blinding);
 180     BN_BLINDING_free(r->mt_blinding);
 181     OPENSSL_free(r);
 182 }
 183
 184 int RSA_up_ref(RSA *r)
 185 {
 186     int i;
 187
 188     if (CRYPTO_UP_REF(&r->references, &i) <= 0)
 189         return 0;
 190
 191     REF_PRINT_COUNT("RSA", r);
 192     REF_ASSERT_ISNT(i < 2);
 193     return i > 1 ? 1 : 0;
 194 }
 195
 196 OSSL_LIB_CTX *ossl_rsa_get0_libctx(RSA *r)
 197 {
 198     return r->libctx;
 199 }
 200
 201 void ossl_rsa_set0_libctx(RSA *r, OSSL_LIB_CTX *libctx)
 202 {
 203     r->libctx = libctx;
 204 }
 205
 206 #ifndef FIPS_MODULE
 207 int RSA_set_ex_data(RSA *r, int idx, void *arg)
 208 {
 209     return CRYPTO_set_ex_data(&r->ex_data, idx, arg);
 210 }
 211
 212 void *RSA_get_ex_data(const RSA *r, int idx)
 213 {
 214     return CRYPTO_get_ex_data(&r->ex_data, idx);
 215 }
 216 #endif
 217
 218 /*
 219  * Define a scaling constant for our fixed point arithmetic.
 220  * This value must be a power of two because the base two logarithm code
 221  * makes this assumption.  The exponent must also be a multiple of three so
 222  * that the scale factor has an exact cube root.  Finally, the scale factor
 223  * should not be so large that a multiplication of two scaled numbers
 224  * overflows a 64 bit unsigned integer.
 225  */
 226 static const unsigned int scale = 1 << 18;
 227 static const unsigned int cbrt_scale = 1 << (2 * 18 / 3);
 228
 229 /* Define some constants, none exceed 32 bits */
 230 static const unsigned int log_2  = 0x02c5c8;    /* scale * log(2) */
 231 static const unsigned int log_e  = 0x05c551;    /* scale * log2(M_E) */
 232 static const unsigned int c1_923 = 0x07b126;    /* scale * 1.923 */
 233 static const unsigned int c4_690 = 0x12c28f;    /* scale * 4.690 */
 234
 235 /*
 236  * Multiply two scaled integers together and rescale the result.
 237  */
 238 static ossl_inline uint64_t mul2(uint64_t a, uint64_t b)
 239 {
 240     return a * b / scale;
 241 }
 242
 243 /*
 244  * Calculate the cube root of a 64 bit scaled integer.
 245  * Although the cube root of a 64 bit number does fit into a 32 bit unsigned
 246  * integer, this is not guaranteed after scaling, so this function has a
 247  * 64 bit return.  This uses the shifting nth root algorithm with some
 248  * algebraic simplifications.
 249  */
 250 static uint64_t icbrt64(uint64_t x)
 251 {
 252     uint64_t r = 0;
 253     uint64_t b;
 254     int s;
 255
 256     for (s = 63; s >= 0; s -= 3) {
 257         r <<= 1;
 258         b = 3 * r * (r + 1) + 1;
 259         if ((x >> s) >= b) {
 260             x -= b << s;
 261             r++;
 262         }
 263     }
 264     return r * cbrt_scale;
 265 }
 266
 267 /*
 268  * Calculate the natural logarithm of a 64 bit scaled integer.
 269  * This is done by calculating a base two logarithm and scaling.
 270  * The maximum logarithm (base 2) is 64 and this reduces base e, so
 271  * a 32 bit result should not overflow.  The argument passed must be
 272  * greater than unity so we don't need to handle negative results.
 273  */
 274 static uint32_t ilog_e(uint64_t v)
 275 {
 276     uint32_t i, r = 0;
 277
 278     /*
 279      * Scale down the value into the range 1 .. 2.
 280      *
 281      * If fractional numbers need to be processed, another loop needs
 282      * to go here that checks v < scale and if so multiplies it by 2 and
 283      * reduces r by scale.  This also means making r signed.
 284      */
 285     while (v >= 2 * scale) {
 286         v >>= 1;
 287         r += scale;
 288     }
 289     for (i = scale / 2; i != 0; i /= 2) {
 290         v = mul2(v, v);
 291         if (v >= 2 * scale) {
 292             v >>= 1;
 293             r += i;
 294         }
 295     }
 296     r = (r * (uint64_t)scale) / log_e;
 297     return r;
 298 }
 299
 300 /*
 301  * NIST SP 800-56B rev 2 Appendix D: Maximum Security Strength Estimates for IFC
 302  * Modulus Lengths.
 303  *
 304  * Note that this formula is also referred to in SP800-56A rev3 Appendix D:
 305  * for FFC safe prime groups for modp and ffdhe.
 306  * After Table 25 and Table 26 it refers to
 307  * "The maximum security strength estimates were calculated using the formula in
 308  * Section 7.5 of the FIPS 140 IG and rounded to the nearest multiple of eight
 309  * bits".
 310  *
 311  * The formula is:
 312  *
 313  * E = \frac{1.923 \sqrt[3]{nBits \cdot log_e(2)}
 314  *           \cdot(log_e(nBits \cdot log_e(2))^{2/3} - 4.69}{log_e(2)}
 315  * The two cube roots are merged together here.
 316  */
 317 uint16_t ossl_ifc_ffc_compute_security_bits(int n)
 318 {
 319     uint64_t x;
 320     uint32_t lx;
 321     uint16_t y, cap;
 322
 323     /*
 324      * Look for common values as listed in standards.
 325      * These values are not exactly equal to the results from the formulae in
 326      * the standards but are defined to be canonical.
 327      */
 328     switch (n) {
 329     case 2048:      /* SP 800-56B rev 2 Appendix D and FIPS 140-2 IG 7.5 */
 330         return 112;
 331     case 3072:      /* SP 800-56B rev 2 Appendix D and FIPS 140-2 IG 7.5 */
 332         return 128;
 333     case 4096:      /* SP 800-56B rev 2 Appendix D */
 334         return 152;
 335     case 6144:      /* SP 800-56B rev 2 Appendix D */
 336         return 176;
 337     case 7680:      /* FIPS 140-2 IG 7.5 */
 338         return 192;
 339     case 8192:      /* SP 800-56B rev 2 Appendix D */
 340         return 200;
 341     case 15360:     /* FIPS 140-2 IG 7.5 */
 342         return 256;
 343     }
 344
 345     /*
 346      * The first incorrect result (i.e. not accurate or off by one low) occurs
 347      * for n = 699668.  The true value here is 1200.  Instead of using this n
 348      * as the check threshold, the smallest n such that the correct result is
 349      * 1200 is used instead.
 350      */
 351     if (n >= 687737)
 352         return 1200;
 353     if (n < 8)
 354         return 0;
 355
 356     /*
 357      * To ensure that the output is non-decreasing with respect to n,
 358      * a cap needs to be applied to the two values where the function over
 359      * estimates the strength (according to the above fast path).
 360      */
 361     if (n <= 7680)
 362         cap = 192;
 363     else if (n <= 15360)
 364         cap = 256;
 365     else
 366         cap = 1200;
 367
 368     x = n * (uint64_t)log_2;
 369     lx = ilog_e(x);
 370     y = (uint16_t)((mul2(c1_923, icbrt64(mul2(mul2(x, lx), lx))) - c4_690)
 371                    / log_2);
 372     y = (y + 4) & ~7;
 373     if (y > cap)
 374         y = cap;
 375     return y;
 376 }
 377
 378
 379
 380 int RSA_security_bits(const RSA *rsa)
 381 {
 382     int bits = BN_num_bits(rsa->n);
 383
 384 #ifndef FIPS_MODULE
 385     if (rsa->version == RSA_ASN1_VERSION_MULTI) {
 386         /* This ought to mean that we have private key at hand. */
 387         int ex_primes = sk_RSA_PRIME_INFO_num(rsa->prime_infos);
 388
 389         if (ex_primes <= 0 || (ex_primes + 2) > ossl_rsa_multip_cap(bits))
 390             return 0;
 391     }
 392 #endif
 393     return ossl_ifc_ffc_compute_security_bits(bits);
 394 }
 395
 396 int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d)
 397 {
 398     /* If the fields n and e in r are NULL, the corresponding input
 399      * parameters MUST be non-NULL for n and e.  d may be
 400      * left NULL (in case only the public key is used).
 401      */
 402     if ((r->n == NULL && n == NULL)
 403         || (r->e == NULL && e == NULL))
 404         return 0;
 405
 406     if (n != NULL) {
 407         BN_free(r->n);
 408         r->n = n;
 409     }
 410     if (e != NULL) {
 411         BN_free(r->e);
 412         r->e = e;
 413     }
 414     if (d != NULL) {
 415         BN_clear_free(r->d);
 416         r->d = d;
 417         BN_set_flags(r->d, BN_FLG_CONSTTIME);
 418     }
 419     r->dirty_cnt++;
 420
 421     return 1;
 422 }
 423
 424 int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q)
 425 {
 426     /* If the fields p and q in r are NULL, the corresponding input
 427      * parameters MUST be non-NULL.
 428      */
 429     if ((r->p == NULL && p == NULL)
 430         || (r->q == NULL && q == NULL))
 431         return 0;
 432
 433     if (p != NULL) {
 434         BN_clear_free(r->p);
 435         r->p = p;
 436         BN_set_flags(r->p, BN_FLG_CONSTTIME);
 437     }
 438     if (q != NULL) {
 439         BN_clear_free(r->q);
 440         r->q = q;
 441         BN_set_flags(r->q, BN_FLG_CONSTTIME);
 442     }
 443     r->dirty_cnt++;
 444
 445     return 1;
 446 }
 447
 448 int RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp)
 449 {
 450     /* If the fields dmp1, dmq1 and iqmp in r are NULL, the corresponding input
 451      * parameters MUST be non-NULL.
 452      */
 453     if ((r->dmp1 == NULL && dmp1 == NULL)
 454         || (r->dmq1 == NULL && dmq1 == NULL)
 455         || (r->iqmp == NULL && iqmp == NULL))
 456         return 0;
 457
 458     if (dmp1 != NULL) {
 459         BN_clear_free(r->dmp1);
 460         r->dmp1 = dmp1;
 461         BN_set_flags(r->dmp1, BN_FLG_CONSTTIME);
 462     }
 463     if (dmq1 != NULL) {
 464         BN_clear_free(r->dmq1);
 465         r->dmq1 = dmq1;
 466         BN_set_flags(r->dmq1, BN_FLG_CONSTTIME);
 467     }
 468     if (iqmp != NULL) {
 469         BN_clear_free(r->iqmp);
 470         r->iqmp = iqmp;
 471         BN_set_flags(r->iqmp, BN_FLG_CONSTTIME);
 472     }
 473     r->dirty_cnt++;
 474
 475     return 1;
 476 }
 477
 478 #ifndef FIPS_MODULE
 479 /*
 480  * Is it better to export RSA_PRIME_INFO structure
 481  * and related functions to let user pass a triplet?
 482  */
 483 int RSA_set0_multi_prime_params(RSA *r, BIGNUM *primes[], BIGNUM *exps[],
 484                                 BIGNUM *coeffs[], int pnum)
 485 {
 486     STACK_OF(RSA_PRIME_INFO) *prime_infos, *old = NULL;
 487     RSA_PRIME_INFO *pinfo;
 488     int i;
 489
 490     if (primes == NULL || exps == NULL || coeffs == NULL || pnum == 0)
 491         return 0;
 492
 493     prime_infos = sk_RSA_PRIME_INFO_new_reserve(NULL, pnum);
 494     if (prime_infos == NULL)
 495         return 0;
 496
 497     if (r->prime_infos != NULL)
 498         old = r->prime_infos;
 499
 500     for (i = 0; i < pnum; i++) {
 501         pinfo = ossl_rsa_multip_info_new();
 502         if (pinfo == NULL)
 503             goto err;
 504         if (primes[i] != NULL && exps[i] != NULL && coeffs[i] != NULL) {
 505             BN_clear_free(pinfo->r);
 506             BN_clear_free(pinfo->d);
 507             BN_clear_free(pinfo->t);
 508             pinfo->r = primes[i];
 509             pinfo->d = exps[i];
 510             pinfo->t = coeffs[i];
 511             BN_set_flags(pinfo->r, BN_FLG_CONSTTIME);
 512             BN_set_flags(pinfo->d, BN_FLG_CONSTTIME);
 513             BN_set_flags(pinfo->t, BN_FLG_CONSTTIME);
 514         } else {
 515             ossl_rsa_multip_info_free(pinfo);
 516             goto err;
 517         }
 518         (void)sk_RSA_PRIME_INFO_push(prime_infos, pinfo);
 519     }
 520
 521     r->prime_infos = prime_infos;
 522
 523     if (!ossl_rsa_multip_calc_product(r)) {
 524         r->prime_infos = old;
 525         goto err;
 526     }
 527
 528     if (old != NULL) {
 529         /*
 530          * This is hard to deal with, since the old infos could
 531          * also be set by this function and r, d, t should not
 532          * be freed in that case. So currently, stay consistent
 533          * with other *set0* functions: just free it...
 534          */
 535         sk_RSA_PRIME_INFO_pop_free(old, ossl_rsa_multip_info_free);
 536     }
 537
 538     r->version = RSA_ASN1_VERSION_MULTI;
 539     r->dirty_cnt++;
 540
 541     return 1;
 542  err:
 543     /* r, d, t should not be freed */
 544     sk_RSA_PRIME_INFO_pop_free(prime_infos, ossl_rsa_multip_info_free_ex);
 545     return 0;
 546 }
 547 #endif
 548
 549 void RSA_get0_key(const RSA *r,
 550                   const BIGNUM **n, const BIGNUM **e, const BIGNUM **d)
 551 {
 552     if (n != NULL)
 553         *n = r->n;
 554     if (e != NULL)
 555         *e = r->e;
 556     if (d != NULL)
 557         *d = r->d;
 558 }
 559
 560 void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q)
 561 {
 562     if (p != NULL)
 563         *p = r->p;
 564     if (q != NULL)
 565         *q = r->q;
 566 }
 567
 568 #ifndef FIPS_MODULE
 569 int RSA_get_multi_prime_extra_count(const RSA *r)
 570 {
 571     int pnum;
 572
 573     pnum = sk_RSA_PRIME_INFO_num(r->prime_infos);
 574     if (pnum <= 0)
 575         pnum = 0;
 576     return pnum;
 577 }
 578
 579 int RSA_get0_multi_prime_factors(const RSA *r, const BIGNUM *primes[])
 580 {
 581     int pnum, i;
 582     RSA_PRIME_INFO *pinfo;
 583
 584     if ((pnum = RSA_get_multi_prime_extra_count(r)) == 0)
 585         return 0;
 586
 587     /*
 588      * return other primes
 589      * it's caller's responsibility to allocate oth_primes[pnum]
 590      */
 591     for (i = 0; i < pnum; i++) {
 592         pinfo = sk_RSA_PRIME_INFO_value(r->prime_infos, i);
 593         primes[i] = pinfo->r;
 594     }
 595
 596     return 1;
 597 }
 598 #endif
 599
 600 void RSA_get0_crt_params(const RSA *r,
 601                          const BIGNUM **dmp1, const BIGNUM **dmq1,
 602                          const BIGNUM **iqmp)
 603 {
 604     if (dmp1 != NULL)
 605         *dmp1 = r->dmp1;
 606     if (dmq1 != NULL)
 607         *dmq1 = r->dmq1;
 608     if (iqmp != NULL)
 609         *iqmp = r->iqmp;
 610 }
 611
 612 #ifndef FIPS_MODULE
 613 int RSA_get0_multi_prime_crt_params(const RSA *r, const BIGNUM *exps[],
 614                                     const BIGNUM *coeffs[])
 615 {
 616     int pnum;
 617
 618     if ((pnum = RSA_get_multi_prime_extra_count(r)) == 0)
 619         return 0;
 620
 621     /* return other primes */
 622     if (exps != NULL || coeffs != NULL) {
 623         RSA_PRIME_INFO *pinfo;
 624         int i;
 625
 626         /* it's the user's job to guarantee the buffer length */
 627         for (i = 0; i < pnum; i++) {
 628             pinfo = sk_RSA_PRIME_INFO_value(r->prime_infos, i);
 629             if (exps != NULL)
 630                 exps[i] = pinfo->d;
 631             if (coeffs != NULL)
 632                 coeffs[i] = pinfo->t;
 633         }
 634     }
 635
 636     return 1;
 637 }
 638 #endif
 639
 640 const BIGNUM *RSA_get0_n(const RSA *r)
 641 {
 642     return r->n;
 643 }
 644
 645 const BIGNUM *RSA_get0_e(const RSA *r)
 646 {
 647     return r->e;
 648 }
 649
 650 const BIGNUM *RSA_get0_d(const RSA *r)
 651 {
 652     return r->d;
 653 }
 654
 655 const BIGNUM *RSA_get0_p(const RSA *r)
 656 {
 657     return r->p;
 658 }
 659
 660 const BIGNUM *RSA_get0_q(const RSA *r)
 661 {
 662     return r->q;
 663 }
 664
 665 const BIGNUM *RSA_get0_dmp1(const RSA *r)
 666 {
 667     return r->dmp1;
 668 }
 669
 670 const BIGNUM *RSA_get0_dmq1(const RSA *r)
 671 {
 672     return r->dmq1;
 673 }
 674
 675 const BIGNUM *RSA_get0_iqmp(const RSA *r)
 676 {
 677     return r->iqmp;
 678 }
 679
 680 const RSA_PSS_PARAMS *RSA_get0_pss_params(const RSA *r)
 681 {
 682 #ifdef FIPS_MODULE
 683     return NULL;
 684 #else
 685     return r->pss;
 686 #endif
 687 }
 688
 689 /* Internal */
 690 int ossl_rsa_set0_pss_params(RSA *r, RSA_PSS_PARAMS *pss)
 691 {
 692 #ifdef FIPS_MODULE
 693     return 0;
 694 #else
 695     RSA_PSS_PARAMS_free(r->pss);
 696     r->pss = pss;
 697     return 1;
 698 #endif
 699 }
 700
 701 /* Internal */
 702 RSA_PSS_PARAMS_30 *ossl_rsa_get0_pss_params_30(RSA *r)
 703 {
 704     return &r->pss_params;
 705 }
 706
 707 void RSA_clear_flags(RSA *r, int flags)
 708 {
 709     r->flags &= ~flags;
 710 }
 711
 712 int RSA_test_flags(const RSA *r, int flags)
 713 {
 714     return r->flags & flags;
 715 }
 716
 717 void RSA_set_flags(RSA *r, int flags)
 718 {
 719     r->flags |= flags;
 720 }
 721
 722 int RSA_get_version(RSA *r)
 723 {
 724     /* { two-prime(0), multi(1) } */
 725     return r->version;
 726 }
 727
 728 #ifndef FIPS_MODULE
 729 ENGINE *RSA_get0_engine(const RSA *r)
 730 {
 731     return r->engine;
 732 }
 733
 734 int RSA_pkey_ctx_ctrl(EVP_PKEY_CTX *ctx, int optype, int cmd, int p1, void *p2)
 735 {
 736     /* If key type not RSA or RSA-PSS return error */
 737     if (ctx != NULL && ctx->pmeth != NULL
 738         && ctx->pmeth->pkey_id != EVP_PKEY_RSA
 739         && ctx->pmeth->pkey_id != EVP_PKEY_RSA_PSS)
 740         return -1;
 741      return EVP_PKEY_CTX_ctrl(ctx, -1, optype, cmd, p1, p2);
 742 }
 743 #endif
 744
 745 DEFINE_STACK_OF(BIGNUM)
 746
 747 /*
 748  * Note: This function deletes values from the parameter
 749  * stack values as they are consumed and set in the RSA key.
 750  */
 751 int ossl_rsa_set0_all_params(RSA *r, STACK_OF(BIGNUM) *primes,
 752                              STACK_OF(BIGNUM) *exps,
 753                              STACK_OF(BIGNUM) *coeffs)
 754 {
 755 #ifndef FIPS_MODULE
 756     STACK_OF(RSA_PRIME_INFO) *prime_infos, *old_infos = NULL;
 757 #endif
 758     int pnum;
 759
 760     if (primes == NULL || exps == NULL || coeffs == NULL)
 761         return 0;
 762
 763     pnum = sk_BIGNUM_num(primes);
 764
 765     /* we need at least 2 primes */
 766     if (pnum < 2)
 767         return 0;
 768
 769     if (!RSA_set0_factors(r, sk_BIGNUM_value(primes, 0),
 770                           sk_BIGNUM_value(primes, 1)))
 771         return 0;
 772
 773     /*
 774      * if we managed to set everything above, remove those elements from the
 775      * stack
 776      * Note, we do this after the above all to ensure that we have taken
 777      * ownership of all the elements in the RSA key to avoid memory leaks
 778      * we also use delete 0 here as we are grabbing items from the end of the
 779      * stack rather than the start, otherwise we could use pop
 780      */
 781     sk_BIGNUM_delete(primes, 0);
 782     sk_BIGNUM_delete(primes, 0);
 783
 784     if (pnum == sk_BIGNUM_num(exps)
 785         && pnum == sk_BIGNUM_num(coeffs) + 1) {
 786
 787         if (!RSA_set0_crt_params(r, sk_BIGNUM_value(exps, 0),
 788                                  sk_BIGNUM_value(exps, 1),
 789                                  sk_BIGNUM_value(coeffs, 0)))
 790         return 0;
 791
 792         /* as above, once we consume the above params, delete them from the list */
 793         sk_BIGNUM_delete(exps, 0);
 794         sk_BIGNUM_delete(exps, 0);
 795         sk_BIGNUM_delete(coeffs, 0);
 796     }
 797
 798 #ifndef FIPS_MODULE
 799     old_infos = r->prime_infos;
 800 #endif
 801
 802     if (pnum > 2) {
 803 #ifndef FIPS_MODULE
 804         int i;
 805
 806         prime_infos = sk_RSA_PRIME_INFO_new_reserve(NULL, pnum);
 807         if (prime_infos == NULL)
 808             return 0;
 809
 810         for (i = 2; i < pnum; i++) {
 811             BIGNUM *prime = sk_BIGNUM_pop(primes);
 812             BIGNUM *exp = sk_BIGNUM_pop(exps);
 813             BIGNUM *coeff = sk_BIGNUM_pop(coeffs);
 814             RSA_PRIME_INFO *pinfo = NULL;
 815
 816             if (!ossl_assert(prime != NULL && exp != NULL && coeff != NULL))
 817                 goto err;
 818
 819             /* Using ossl_rsa_multip_info_new() is wasteful, so allocate directly */
 820             if ((pinfo = OPENSSL_zalloc(sizeof(*pinfo))) == NULL)
 821                 goto err;
 822
 823             pinfo->r = prime;
 824             pinfo->d = exp;
 825             pinfo->t = coeff;
 826             BN_set_flags(pinfo->r, BN_FLG_CONSTTIME);
 827             BN_set_flags(pinfo->d, BN_FLG_CONSTTIME);
 828             BN_set_flags(pinfo->t, BN_FLG_CONSTTIME);
 829             (void)sk_RSA_PRIME_INFO_push(prime_infos, pinfo);
 830         }
 831
 832         r->prime_infos = prime_infos;
 833
 834         if (!ossl_rsa_multip_calc_product(r)) {
 835             r->prime_infos = old_infos;
 836             goto err;
 837         }
 838 #else
 839         return 0;
 840 #endif
 841     }
 842
 843 #ifndef FIPS_MODULE
 844     if (old_infos != NULL) {
 845         /*
 846          * This is hard to deal with, since the old infos could
 847          * also be set by this function and r, d, t should not
 848          * be freed in that case. So currently, stay consistent
 849          * with other *set0* functions: just free it...
 850          */
 851         sk_RSA_PRIME_INFO_pop_free(old_infos, ossl_rsa_multip_info_free);
 852     }
 853 #endif
 854
 855     r->version = pnum > 2 ? RSA_ASN1_VERSION_MULTI : RSA_ASN1_VERSION_DEFAULT;
 856     r->dirty_cnt++;
 857
 858     return 1;
 859 #ifndef FIPS_MODULE
 860  err:
 861     /* r, d, t should not be freed */
 862     sk_RSA_PRIME_INFO_pop_free(prime_infos, ossl_rsa_multip_info_free_ex);
 863     return 0;
 864 #endif
 865 }
 866
 867 DEFINE_SPECIAL_STACK_OF_CONST(BIGNUM_const, BIGNUM)
 868
 869 int ossl_rsa_get0_all_params(RSA *r, STACK_OF(BIGNUM_const) *primes,
 870                              STACK_OF(BIGNUM_const) *exps,
 871                              STACK_OF(BIGNUM_const) *coeffs)
 872 {
 873 #ifndef FIPS_MODULE
 874     RSA_PRIME_INFO *pinfo;
 875     int i, pnum;
 876 #endif
 877
 878     if (r == NULL)
 879         return 0;
 880
 881     /* If |p| is NULL, there are no CRT parameters */
 882     if (RSA_get0_p(r) == NULL)
 883         return 1;
 884
 885     sk_BIGNUM_const_push(primes, RSA_get0_p(r));
 886     sk_BIGNUM_const_push(primes, RSA_get0_q(r));
 887     sk_BIGNUM_const_push(exps, RSA_get0_dmp1(r));
 888     sk_BIGNUM_const_push(exps, RSA_get0_dmq1(r));
 889     sk_BIGNUM_const_push(coeffs, RSA_get0_iqmp(r));
 890
 891 #ifndef FIPS_MODULE
 892     pnum = RSA_get_multi_prime_extra_count(r);
 893     for (i = 0; i < pnum; i++) {
 894         pinfo = sk_RSA_PRIME_INFO_value(r->prime_infos, i);
 895         sk_BIGNUM_const_push(primes, pinfo->r);
 896         sk_BIGNUM_const_push(exps, pinfo->d);
 897         sk_BIGNUM_const_push(coeffs, pinfo->t);
 898     }
 899 #endif
 900
 901     return 1;
 902 }
 903
 904 #ifndef FIPS_MODULE
 905 /* Helpers to set or get diverse hash algorithm names */
 906 static int int_set_rsa_md_name(EVP_PKEY_CTX *ctx,
 907                                /* For checks */
 908                                int keytype, int optype,
 909                                /* For EVP_PKEY_CTX_set_params() */
 910                                const char *mdkey, const char *mdname,
 911                                const char *propkey, const char *mdprops)
 912 {
 913     OSSL_PARAM params[3], *p = params;
 914
 915     if (ctx == NULL || mdname == NULL || (ctx->operation & optype) == 0) {
 916         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 917         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 918         return -2;
 919     }
 920
 921     /* If key type not RSA return error */
 922     switch (keytype) {
 923     case -1:
 924         if (!EVP_PKEY_CTX_is_a(ctx, "RSA")
 925             && !EVP_PKEY_CTX_is_a(ctx, "RSA-PSS"))
 926             return -1;
 927         break;
 928     default:
 929         if (!EVP_PKEY_CTX_is_a(ctx, evp_pkey_type2name(keytype)))
 930             return -1;
 931         break;
 932     }
 933
 934     /* Cast away the const. This is read only so should be safe */
 935     *p++ = OSSL_PARAM_construct_utf8_string(mdkey, (char *)mdname, 0);
 936     if (evp_pkey_ctx_is_provided(ctx) && mdprops != NULL) {
 937         /* Cast away the const. This is read only so should be safe */
 938         *p++ = OSSL_PARAM_construct_utf8_string(propkey, (char *)mdprops, 0);
 939     }
 940     *p++ = OSSL_PARAM_construct_end();
 941
 942     return evp_pkey_ctx_set_params_strict(ctx, params);
 943 }
 944
 945 /* Helpers to set or get diverse hash algorithm names */
 946 static int int_get_rsa_md_name(EVP_PKEY_CTX *ctx,
 947                                /* For checks */
 948                                int keytype, int optype,
 949                                /* For EVP_PKEY_CTX_get_params() */
 950                                const char *mdkey,
 951                                char *mdname, size_t mdnamesize)
 952 {
 953     OSSL_PARAM params[2], *p = params;
 954
 955     if (ctx == NULL || mdname == NULL || (ctx->operation & optype) == 0) {
 956         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
 957         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
 958         return -2;
 959     }
 960
 961     /* If key type not RSA return error */
 962     switch (keytype) {
 963     case -1:
 964         if (!EVP_PKEY_CTX_is_a(ctx, "RSA")
 965             && !EVP_PKEY_CTX_is_a(ctx, "RSA-PSS"))
 966             return -1;
 967         break;
 968     default:
 969         if (!EVP_PKEY_CTX_is_a(ctx, evp_pkey_type2name(keytype)))
 970             return -1;
 971         break;
 972     }
 973
 974     /* Cast away the const. This is read only so should be safe */
 975     *p++ = OSSL_PARAM_construct_utf8_string(mdkey, (char *)mdname, mdnamesize);
 976     *p++ = OSSL_PARAM_construct_end();
 977
 978     return evp_pkey_ctx_get_params_strict(ctx, params);
 979 }
 980
 981 /*
 982  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
 983  * simply because that's easier.
 984  */
 985 int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *ctx, int pad_mode)
 986 {
 987     return RSA_pkey_ctx_ctrl(ctx, -1, EVP_PKEY_CTRL_RSA_PADDING,
 988                              pad_mode, NULL);
 989 }
 990
 991 /*
 992  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
 993  * simply because that's easier.
 994  */
 995 int EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX *ctx, int *pad_mode)
 996 {
 997     return RSA_pkey_ctx_ctrl(ctx, -1, EVP_PKEY_CTRL_GET_RSA_PADDING,
 998                              0, pad_mode);
 999 }
1000
1001 /*
1002  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
1003  * simply because that's easier.
1004  */
1005 int EVP_PKEY_CTX_set_rsa_pss_keygen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md)
1006 {
1007     return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN,
1008                              EVP_PKEY_CTRL_MD, 0, (void *)(md));
1009 }
1010
1011 int EVP_PKEY_CTX_set_rsa_pss_keygen_md_name(EVP_PKEY_CTX *ctx,
1012                                             const char *mdname,
1013                                             const char *mdprops)
1014 {
1015     return int_set_rsa_md_name(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN,
1016                                OSSL_PKEY_PARAM_RSA_DIGEST, mdname,
1017                                OSSL_PKEY_PARAM_RSA_DIGEST_PROPS, mdprops);
1018 }
1019
1020 /*
1021  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
1022  * simply because that's easier.
1023  */
1024 int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD *md)
1025 {
1026     /* If key type not RSA return error */
1027     if (!EVP_PKEY_CTX_is_a(ctx, "RSA"))
1028         return -1;
1029
1030     return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
1031                              EVP_PKEY_CTRL_RSA_OAEP_MD, 0, (void *)(md));
1032 }
1033
1034 int EVP_PKEY_CTX_set_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
1035                                       const char *mdprops)
1036 {
1037     return
1038         int_set_rsa_md_name(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
1039                             OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST, mdname,
1040                             OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS, mdprops);
1041 }
1042
1043 int EVP_PKEY_CTX_get_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, char *name,
1044                                       size_t namesize)
1045 {
1046     return int_get_rsa_md_name(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
1047                                OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST,
1048                                name, namesize);
1049 }
1050
1051 /*
1052  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
1053  * simply because that's easier.
1054  */
1055 int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD **md)
1056 {
1057     /* If key type not RSA return error */
1058     if (!EVP_PKEY_CTX_is_a(ctx, "RSA"))
1059         return -1;
1060
1061     return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT,
1062                              EVP_PKEY_CTRL_GET_RSA_OAEP_MD, 0, (void *)md);
1063 }
1064
1065 /*
1066  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
1067  * simply because that's easier.
1068  */
1069 int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md)
1070 {
1071     return RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
1072                              EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)(md));
1073 }
1074
1075 int EVP_PKEY_CTX_set_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
1076                                       const char *mdprops)
1077 {
1078     return int_set_rsa_md_name(ctx, -1,
1079                                EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
1080                                OSSL_PKEY_PARAM_MGF1_DIGEST, mdname,
1081                                OSSL_PKEY_PARAM_MGF1_PROPERTIES, mdprops);
1082 }
1083
1084 int EVP_PKEY_CTX_get_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, char *name,
1085                                       size_t namesize)
1086 {
1087     return int_get_rsa_md_name(ctx, -1,
1088                                EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_TYPE_SIG,
1089                                OSSL_PKEY_PARAM_MGF1_DIGEST, name, namesize);
1090 }
1091
1092 /*
1093  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
1094  * simply because that's easier.
1095  */
1096 int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md)
1097 {
1098     return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN,
1099                              EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)(md));
1100 }
1101
1102 int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md_name(EVP_PKEY_CTX *ctx,
1103                                                  const char *mdname)
1104 {
1105     return int_set_rsa_md_name(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN,
1106                                OSSL_PKEY_PARAM_MGF1_DIGEST, mdname,
1107                                NULL, NULL);
1108 }
1109
1110 /*
1111  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
1112  * simply because that's easier.
1113  */
1114 int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD **md)
1115 {
1116     return RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
1117                              EVP_PKEY_CTRL_GET_RSA_MGF1_MD, 0, (void *)(md));
1118 }
1119
1120 int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX *ctx, void *label, int llen)
1121 {
1122     OSSL_PARAM rsa_params[2], *p = rsa_params;
1123     const char *empty = "";
1124     /*
1125      * Needed as we swap label with empty if it is NULL, and label is
1126      * freed at the end of this function.
1127      */
1128     void *plabel = label;
1129     int ret;
1130
1131     if (ctx == NULL || !EVP_PKEY_CTX_IS_ASYM_CIPHER_OP(ctx)) {
1132         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1133         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
1134         return -2;
1135     }
1136
1137     /* If key type not RSA return error */
1138     if (!EVP_PKEY_CTX_is_a(ctx, "RSA"))
1139         return -1;
1140
1141     /* Accept NULL for backward compatibility */
1142     if (label == NULL && llen == 0)
1143         plabel = (void *)empty;
1144
1145     /* Cast away the const. This is read only so should be safe */
1146     *p++ = OSSL_PARAM_construct_octet_string(OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL,
1147                                              (void *)plabel, (size_t)llen);
1148     *p++ = OSSL_PARAM_construct_end();
1149
1150     ret = evp_pkey_ctx_set_params_strict(ctx, rsa_params);
1151     if (ret <= 0)
1152         return ret;
1153
1154     /* Ownership is supposed to be transferred to the callee. */
1155     OPENSSL_free(label);
1156     return 1;
1157 }
1158
1159 int EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX *ctx, unsigned char **label)
1160 {
1161     OSSL_PARAM rsa_params[2], *p = rsa_params;
1162     size_t labellen;
1163
1164     if (ctx == NULL || !EVP_PKEY_CTX_IS_ASYM_CIPHER_OP(ctx)) {
1165         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1166         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
1167         return -2;
1168     }
1169
1170     /* If key type not RSA return error */
1171     if (!EVP_PKEY_CTX_is_a(ctx, "RSA"))
1172         return -1;
1173
1174     *p++ = OSSL_PARAM_construct_octet_ptr(OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL,
1175                                           (void **)label, 0);
1176     *p++ = OSSL_PARAM_construct_end();
1177
1178     if (!EVP_PKEY_CTX_get_params(ctx, rsa_params))
1179         return -1;
1180
1181     labellen = rsa_params[0].return_size;
1182     if (labellen > INT_MAX)
1183         return -1;
1184
1185     return (int)labellen;
1186 }
1187
1188 /*
1189  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
1190  * simply because that's easier.
1191  */
1192 int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int saltlen)
1193 {
1194     /*
1195      * For some reason, the optype was set to this:
1196      *
1197      * EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY
1198      *
1199      * However, we do use RSA-PSS with the whole gamut of diverse signature
1200      * and verification operations, so the optype gets upgraded to this:
1201      *
1202      * EVP_PKEY_OP_TYPE_SIG
1203      */
1204     return RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG,
1205                              EVP_PKEY_CTRL_RSA_PSS_SALTLEN, saltlen, NULL);
1206 }
1207
1208 /*
1209  * This one is currently implemented as an EVP_PKEY_CTX_ctrl() wrapper,
1210  * simply because that's easier.
1211  */
1212 int EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int *saltlen)
1213 {
1214     /*
1215      * Because of circumstances, the optype is updated from:
1216      *
1217      * EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY
1218      *
1219      * to:
1220      *
1221      * EVP_PKEY_OP_TYPE_SIG
1222      */
1223     return RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG,
1224                              EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN, 0, saltlen);
1225 }
1226
1227 int EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(EVP_PKEY_CTX *ctx, int saltlen)
1228 {
1229     OSSL_PARAM pad_params[2], *p = pad_params;
1230
1231     if (ctx == NULL || !EVP_PKEY_CTX_IS_GEN_OP(ctx)) {
1232         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1233         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
1234         return -2;
1235     }
1236
1237     if (!EVP_PKEY_CTX_is_a(ctx, "RSA-PSS"))
1238         return -1;
1239
1240     *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_PSS_SALTLEN,
1241                                     &saltlen);
1242     *p++ = OSSL_PARAM_construct_end();
1243
1244     return evp_pkey_ctx_set_params_strict(ctx, pad_params);
1245 }
1246
1247 int EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX *ctx, int bits)
1248 {
1249     OSSL_PARAM params[2], *p = params;
1250     size_t bits2 = bits;
1251
1252     if (ctx == NULL || !EVP_PKEY_CTX_IS_GEN_OP(ctx)) {
1253         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1254         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
1255         return -2;
1256     }
1257
1258     /* If key type not RSA return error */
1259     if (!EVP_PKEY_CTX_is_a(ctx, "RSA")
1260         && !EVP_PKEY_CTX_is_a(ctx, "RSA-PSS"))
1261         return -1;
1262
1263     *p++ = OSSL_PARAM_construct_size_t(OSSL_PKEY_PARAM_RSA_BITS, &bits2);
1264     *p++ = OSSL_PARAM_construct_end();
1265
1266     return evp_pkey_ctx_set_params_strict(ctx, params);
1267 }
1268
1269 int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp)
1270 {
1271     int ret = RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN,
1272                                 EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, 0, pubexp);
1273
1274     /*
1275      * Satisfy memory semantics for pre-3.0 callers of
1276      * EVP_PKEY_CTX_set_rsa_keygen_pubexp(): their expectation is that input
1277      * pubexp BIGNUM becomes managed by the EVP_PKEY_CTX on success.
1278      */
1279     if (ret > 0 && evp_pkey_ctx_is_provided(ctx)) {
1280         BN_free(ctx->rsa_pubexp);
1281         ctx->rsa_pubexp = pubexp;
1282     }
1283
1284     return ret;
1285 }
1286
1287 int EVP_PKEY_CTX_set1_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp)
1288 {
1289     int ret = 0;
1290
1291     /*
1292      * When we're dealing with a provider, there's no need to duplicate
1293      * pubexp, as it gets copied when transforming to an OSSL_PARAM anyway.
1294      */
1295     if (evp_pkey_ctx_is_legacy(ctx)) {
1296         pubexp = BN_dup(pubexp);
1297         if (pubexp == NULL)
1298             return 0;
1299     }
1300     ret = EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_KEYGEN,
1301                             EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, 0, pubexp);
1302     if (evp_pkey_ctx_is_legacy(ctx) && ret <= 0)
1303         BN_free(pubexp);
1304     return ret;
1305 }
1306
1307 int EVP_PKEY_CTX_set_rsa_keygen_primes(EVP_PKEY_CTX *ctx, int primes)
1308 {
1309     OSSL_PARAM params[2], *p = params;
1310     size_t primes2 = primes;
1311
1312     if (ctx == NULL || !EVP_PKEY_CTX_IS_GEN_OP(ctx)) {
1313         ERR_raise(ERR_LIB_EVP, EVP_R_COMMAND_NOT_SUPPORTED);
1314         /* Uses the same return values as EVP_PKEY_CTX_ctrl */
1315         return -2;
1316     }
1317
1318     /* If key type not RSA return error */
1319     if (!EVP_PKEY_CTX_is_a(ctx, "RSA")
1320         && !EVP_PKEY_CTX_is_a(ctx, "RSA-PSS"))
1321         return -1;
1322
1323     *p++ = OSSL_PARAM_construct_size_t(OSSL_PKEY_PARAM_RSA_PRIMES, &primes2);
1324     *p++ = OSSL_PARAM_construct_end();
1325
1326     return evp_pkey_ctx_set_params_strict(ctx, params);
1327 }
1328 #endif