providers/implementations/signature/rsa.c

   1 /*
   2  * Copyright 2019-2020 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 <string.h>
  17 #include <openssl/crypto.h>
  18 #include <openssl/core_numbers.h>
  19 #include <openssl/core_names.h>
  20 #include <openssl/err.h>
  21 #include <openssl/rsa.h>
  22 #include <openssl/params.h>
  23 #include <openssl/evp.h>
  24 #include "internal/cryptlib.h"
  25 #include "internal/nelem.h"
  26 #include "internal/sizes.h"
  27 #include "crypto/rsa.h"
  28 #include "prov/providercommonerr.h"
  29 #include "prov/implementations.h"
  30 #include "prov/provider_ctx.h"
  31 #include "prov/der_rsa.h"
  32
  33 static OSSL_OP_signature_newctx_fn rsa_newctx;
  34 static OSSL_OP_signature_sign_init_fn rsa_sign_init;
  35 static OSSL_OP_signature_verify_init_fn rsa_verify_init;
  36 static OSSL_OP_signature_verify_recover_init_fn rsa_verify_recover_init;
  37 static OSSL_OP_signature_sign_fn rsa_sign;
  38 static OSSL_OP_signature_verify_fn rsa_verify;
  39 static OSSL_OP_signature_verify_recover_fn rsa_verify_recover;
  40 static OSSL_OP_signature_digest_sign_init_fn rsa_digest_sign_init;
  41 static OSSL_OP_signature_digest_sign_update_fn rsa_digest_signverify_update;
  42 static OSSL_OP_signature_digest_sign_final_fn rsa_digest_sign_final;
  43 static OSSL_OP_signature_digest_verify_init_fn rsa_digest_verify_init;
  44 static OSSL_OP_signature_digest_verify_update_fn rsa_digest_signverify_update;
  45 static OSSL_OP_signature_digest_verify_final_fn rsa_digest_verify_final;
  46 static OSSL_OP_signature_freectx_fn rsa_freectx;
  47 static OSSL_OP_signature_dupctx_fn rsa_dupctx;
  48 static OSSL_OP_signature_get_ctx_params_fn rsa_get_ctx_params;
  49 static OSSL_OP_signature_gettable_ctx_params_fn rsa_gettable_ctx_params;
  50 static OSSL_OP_signature_set_ctx_params_fn rsa_set_ctx_params;
  51 static OSSL_OP_signature_settable_ctx_params_fn rsa_settable_ctx_params;
  52 static OSSL_OP_signature_get_ctx_md_params_fn rsa_get_ctx_md_params;
  53 static OSSL_OP_signature_gettable_ctx_md_params_fn rsa_gettable_ctx_md_params;
  54 static OSSL_OP_signature_set_ctx_md_params_fn rsa_set_ctx_md_params;
  55 static OSSL_OP_signature_settable_ctx_md_params_fn rsa_settable_ctx_md_params;
  56
  57 static OSSL_ITEM padding_item[] = {
  58     { RSA_PKCS1_PADDING,        "pkcs1"  },
  59     { RSA_SSLV23_PADDING,       "sslv23" },
  60     { RSA_NO_PADDING,           "none"   },
  61     { RSA_PKCS1_OAEP_PADDING,   "oaep"   }, /* Correct spelling first */
  62     { RSA_PKCS1_OAEP_PADDING,   "oeap"   },
  63     { RSA_X931_PADDING,         "x931"   },
  64     { RSA_PKCS1_PSS_PADDING,    "pss"    },
  65     { 0,                        NULL     }
  66 };
  67
  68 /*
  69  * What's passed as an actual key is defined by the KEYMGMT interface.
  70  * We happen to know that our KEYMGMT simply passes RSA structures, so
  71  * we use that here too.
  72  */
  73
  74 typedef struct {
  75     OPENSSL_CTX *libctx;
  76     char *propq;
  77     RSA *rsa;
  78     int operation;
  79
  80     /*
  81      * Flag to determine if the hash function can be changed (1) or not (0)
  82      * Because it's dangerous to change during a DigestSign or DigestVerify
  83      * operation, this flag is cleared by their Init function, and set again
  84      * by their Final function.
  85      */
  86     unsigned int flag_allow_md : 1;
  87
  88     /* The Algorithm Identifier of the combined signature agorithm */
  89     unsigned char aid_buf[128];
  90     unsigned char *aid;
  91     size_t  aid_len;
  92
  93     /* main digest */
  94     EVP_MD *md;
  95     EVP_MD_CTX *mdctx;
  96     int mdnid;
  97     char mdname[OSSL_MAX_NAME_SIZE]; /* Purely informational */
  98
  99     /* RSA padding mode */
 100     int pad_mode;
 101     /* message digest for MGF1 */
 102     EVP_MD *mgf1_md;
 103     char mgf1_mdname[OSSL_MAX_NAME_SIZE]; /* Purely informational */
 104     /* PSS salt length */
 105     int saltlen;
 106     /* Minimum salt length or -1 if no PSS parameter restriction */
 107     int min_saltlen;
 108
 109     /* Temp buffer */
 110     unsigned char *tbuf;
 111
 112 } PROV_RSA_CTX;
 113
 114 static size_t rsa_get_md_size(const PROV_RSA_CTX *prsactx)
 115 {
 116     if (prsactx->md != NULL)
 117         return EVP_MD_size(prsactx->md);
 118     return 0;
 119 }
 120
 121 static int rsa_get_md_nid(const EVP_MD *md)
 122 {
 123     /*
 124      * Because the RSA library deals with NIDs, we need to translate.
 125      * We do so using EVP_MD_is_a(), and therefore need a name to NID
 126      * map.
 127      */
 128     static const OSSL_ITEM name_to_nid[] = {
 129         { NID_sha1,      OSSL_DIGEST_NAME_SHA1      },
 130         { NID_sha224,    OSSL_DIGEST_NAME_SHA2_224  },
 131         { NID_sha256,    OSSL_DIGEST_NAME_SHA2_256  },
 132         { NID_sha384,    OSSL_DIGEST_NAME_SHA2_384  },
 133         { NID_sha512,    OSSL_DIGEST_NAME_SHA2_512  },
 134         { NID_sha512_224, OSSL_DIGEST_NAME_SHA2_512_224 },
 135         { NID_sha512_256, OSSL_DIGEST_NAME_SHA2_512_256 },
 136         { NID_md5,       OSSL_DIGEST_NAME_MD5       },
 137         { NID_md5_sha1,  OSSL_DIGEST_NAME_MD5_SHA1  },
 138         { NID_md2,       OSSL_DIGEST_NAME_MD2       },
 139         { NID_md4,       OSSL_DIGEST_NAME_MD4       },
 140         { NID_mdc2,      OSSL_DIGEST_NAME_MDC2      },
 141         { NID_ripemd160, OSSL_DIGEST_NAME_RIPEMD160 },
 142         { NID_sha3_224,  OSSL_DIGEST_NAME_SHA3_224  },
 143         { NID_sha3_256,  OSSL_DIGEST_NAME_SHA3_256  },
 144         { NID_sha3_384,  OSSL_DIGEST_NAME_SHA3_384  },
 145         { NID_sha3_512,  OSSL_DIGEST_NAME_SHA3_512  },
 146     };
 147     size_t i;
 148     int mdnid = NID_undef;
 149
 150     if (md == NULL)
 151         goto end;
 152
 153     for (i = 0; i < OSSL_NELEM(name_to_nid); i++) {
 154         if (EVP_MD_is_a(md, name_to_nid[i].ptr)) {
 155             mdnid = (int)name_to_nid[i].id;
 156             break;
 157         }
 158     }
 159
 160  end:
 161     return mdnid;
 162 }
 163
 164 static int rsa_check_padding(int mdnid, int padding)
 165 {
 166     if (padding == RSA_NO_PADDING) {
 167         ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE);
 168         return 0;
 169     }
 170
 171     if (padding == RSA_X931_PADDING) {
 172         if (RSA_X931_hash_id(mdnid) == -1) {
 173             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_X931_DIGEST);
 174             return 0;
 175         }
 176     }
 177
 178     return 1;
 179 }
 180
 181 static int rsa_check_parameters(EVP_MD *md, PROV_RSA_CTX *prsactx)
 182 {
 183     if (prsactx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 184         int max_saltlen;
 185
 186         /* See if minimum salt length exceeds maximum possible */
 187         max_saltlen = RSA_size(prsactx->rsa) - EVP_MD_size(md);
 188         if ((RSA_bits(prsactx->rsa) & 0x7) == 1)
 189             max_saltlen--;
 190         if (prsactx->min_saltlen > max_saltlen) {
 191             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_SALT_LENGTH);
 192             return 0;
 193         }
 194     }
 195     return 1;
 196 }
 197
 198 static void *rsa_newctx(void *provctx, const char *propq)
 199 {
 200     PROV_RSA_CTX *prsactx = NULL;
 201     char *propq_copy = NULL;
 202
 203     if ((prsactx = OPENSSL_zalloc(sizeof(PROV_RSA_CTX))) == NULL
 204         || (propq != NULL
 205             && (propq_copy = OPENSSL_strdup(propq)) == NULL)) {
 206         OPENSSL_free(prsactx);
 207         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 208         return NULL;
 209     }
 210
 211     prsactx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
 212     prsactx->flag_allow_md = 1;
 213     prsactx->propq = propq_copy;
 214     return prsactx;
 215 }
 216
 217 /* True if PSS parameters are restricted */
 218 #define rsa_pss_restricted(prsactx) (prsactx->min_saltlen != -1)
 219
 220 static int rsa_setup_md(PROV_RSA_CTX *ctx, const char *mdname,
 221                         const char *mdprops)
 222 {
 223     if (mdprops == NULL)
 224         mdprops = ctx->propq;
 225
 226     if (mdname != NULL) {
 227         EVP_MD *md = EVP_MD_fetch(ctx->libctx, mdname, mdprops);
 228         int md_nid = rsa_get_md_nid(md);
 229         WPACKET pkt;
 230
 231         if (md == NULL
 232             || md_nid == NID_undef
 233             || !rsa_check_padding(md_nid, ctx->pad_mode)
 234             || !rsa_check_parameters(md, ctx)) {
 235             if (md == NULL)
 236                 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
 237                                "%s could not be fetched", mdname);
 238             if (md_nid == NID_undef)
 239                 ERR_raise_data(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED,
 240                                "digest=%s", mdname);
 241             EVP_MD_free(md);
 242             return 0;
 243         }
 244
 245         EVP_MD_CTX_free(ctx->mdctx);
 246         EVP_MD_free(ctx->md);
 247
 248         /*
 249          * TODO(3.0) Should we care about DER writing errors?
 250          * All it really means is that for some reason, there's no
 251          * AlgorithmIdentifier to be had (consider RSA with MD5-SHA1),
 252          * but the operation itself is still valid, just as long as it's
 253          * not used to construct anything that needs an AlgorithmIdentifier.
 254          */
 255         ctx->aid_len = 0;
 256         if (WPACKET_init_der(&pkt, ctx->aid_buf, sizeof(ctx->aid_buf))
 257             && DER_w_algorithmIdentifier_MDWithRSAEncryption(&pkt, -1, ctx->rsa,
 258                                                              md_nid)
 259             && WPACKET_finish(&pkt)) {
 260             WPACKET_get_total_written(&pkt, &ctx->aid_len);
 261             ctx->aid = WPACKET_get_curr(&pkt);
 262         }
 263         WPACKET_cleanup(&pkt);
 264
 265         ctx->mdctx = NULL;
 266         ctx->md = md;
 267         ctx->mdnid = md_nid;
 268         OPENSSL_strlcpy(ctx->mdname, mdname, sizeof(ctx->mdname));
 269     }
 270
 271     return 1;
 272 }
 273
 274 static int rsa_setup_mgf1_md(PROV_RSA_CTX *ctx, const char *mdname,
 275                              const char *mdprops)
 276 {
 277     if (mdprops == NULL)
 278         mdprops = ctx->propq;
 279
 280     if (ctx->mgf1_mdname[0] != '\0')
 281         EVP_MD_free(ctx->mgf1_md);
 282
 283     if ((ctx->mgf1_md = EVP_MD_fetch(ctx->libctx, mdname, mdprops)) == NULL) {
 284         ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
 285                        "%s could not be fetched", mdname);
 286         return 0;
 287     }
 288     OPENSSL_strlcpy(ctx->mgf1_mdname, mdname, sizeof(ctx->mgf1_mdname));
 289
 290     return 1;
 291 }
 292
 293 static int rsa_signature_init(void *vprsactx, void *vrsa, int operation)
 294 {
 295     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 296
 297     if (prsactx == NULL || vrsa == NULL || !RSA_up_ref(vrsa))
 298         return 0;
 299
 300     RSA_free(prsactx->rsa);
 301     prsactx->rsa = vrsa;
 302     prsactx->operation = operation;
 303
 304     /* Maximum for sign, auto for verify */
 305     prsactx->saltlen = RSA_PSS_SALTLEN_AUTO;
 306     prsactx->min_saltlen = -1;
 307
 308     switch (RSA_test_flags(prsactx->rsa, RSA_FLAG_TYPE_MASK)) {
 309     case RSA_FLAG_TYPE_RSA:
 310         prsactx->pad_mode = RSA_PKCS1_PADDING;
 311         break;
 312     case RSA_FLAG_TYPE_RSASSAPSS:
 313         prsactx->pad_mode = RSA_PKCS1_PSS_PADDING;
 314
 315         {
 316             const RSA_PSS_PARAMS_30 *pss =
 317                 rsa_get0_pss_params_30(prsactx->rsa);
 318
 319             if (!rsa_pss_params_30_is_unrestricted(pss)) {
 320                 int md_nid = rsa_pss_params_30_hashalg(pss);
 321                 int mgf1md_nid = rsa_pss_params_30_maskgenhashalg(pss);
 322                 int min_saltlen = rsa_pss_params_30_saltlen(pss);
 323                 const char *mdname, *mgf1mdname;
 324
 325                 mdname = rsa_oaeppss_nid2name(md_nid);
 326                 mgf1mdname = rsa_oaeppss_nid2name(mgf1md_nid);
 327                 prsactx->min_saltlen = min_saltlen;
 328
 329                 if (mdname == NULL) {
 330                     ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
 331                                    "PSS restrictions lack hash algorithm");
 332                     return 0;
 333                 }
 334                 if (mgf1mdname == NULL) {
 335                     ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
 336                                    "PSS restrictions lack MGF1 hash algorithm");
 337                     return 0;
 338                 }
 339
 340                 strncpy(prsactx->mdname, mdname, sizeof(prsactx->mdname));
 341                 strncpy(prsactx->mgf1_mdname, mgf1mdname,
 342                         sizeof(prsactx->mgf1_mdname));
 343                 prsactx->saltlen = min_saltlen;
 344
 345                 return rsa_setup_md(prsactx, mdname, prsactx->propq)
 346                     && rsa_setup_mgf1_md(prsactx, mgf1mdname, prsactx->propq);
 347             }
 348         }
 349
 350         break;
 351     default:
 352         ERR_raise(ERR_LIB_RSA, PROV_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 353         return 0;
 354     }
 355
 356     return 1;
 357 }
 358
 359 static int setup_tbuf(PROV_RSA_CTX *ctx)
 360 {
 361     if (ctx->tbuf != NULL)
 362         return 1;
 363     if ((ctx->tbuf = OPENSSL_malloc(RSA_size(ctx->rsa))) == NULL) {
 364         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 365         return 0;
 366     }
 367     return 1;
 368 }
 369
 370 static void clean_tbuf(PROV_RSA_CTX *ctx)
 371 {
 372     if (ctx->tbuf != NULL)
 373         OPENSSL_cleanse(ctx->tbuf, RSA_size(ctx->rsa));
 374 }
 375
 376 static void free_tbuf(PROV_RSA_CTX *ctx)
 377 {
 378     clean_tbuf(ctx);
 379     OPENSSL_free(ctx->tbuf);
 380     ctx->tbuf = NULL;
 381 }
 382
 383 static int rsa_sign_init(void *vprsactx, void *vrsa)
 384 {
 385     return rsa_signature_init(vprsactx, vrsa, EVP_PKEY_OP_SIGN);
 386 }
 387
 388 static int rsa_sign(void *vprsactx, unsigned char *sig, size_t *siglen,
 389                     size_t sigsize, const unsigned char *tbs, size_t tbslen)
 390 {
 391     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 392     int ret;
 393     size_t rsasize = RSA_size(prsactx->rsa);
 394     size_t mdsize = rsa_get_md_size(prsactx);
 395
 396     if (sig == NULL) {
 397         *siglen = rsasize;
 398         return 1;
 399     }
 400
 401     if (sigsize < rsasize) {
 402         ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_SIGNATURE_SIZE,
 403                        "is %zu, should be at least %zu", sigsize, rsasize);
 404         return 0;
 405     }
 406
 407     if (mdsize != 0) {
 408         if (tbslen != mdsize) {
 409             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DIGEST_LENGTH);
 410             return 0;
 411         }
 412
 413 #ifndef FIPS_MODULE
 414         if (EVP_MD_is_a(prsactx->md, OSSL_DIGEST_NAME_MDC2)) {
 415             unsigned int sltmp;
 416
 417             if (prsactx->pad_mode != RSA_PKCS1_PADDING) {
 418                 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE,
 419                                "only PKCS#1 padding supported with MDC2");
 420                 return 0;
 421             }
 422             ret = RSA_sign_ASN1_OCTET_STRING(0, tbs, tbslen, sig, &sltmp,
 423                                              prsactx->rsa);
 424
 425             if (ret <= 0) {
 426                 ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 427                 return 0;
 428             }
 429             ret = sltmp;
 430             goto end;
 431         }
 432 #endif
 433         switch (prsactx->pad_mode) {
 434         case RSA_X931_PADDING:
 435             if ((size_t)RSA_size(prsactx->rsa) < tbslen + 1) {
 436                 ERR_raise_data(ERR_LIB_PROV, PROV_R_KEY_SIZE_TOO_SMALL,
 437                                "RSA key size = %d, expected minimum = %d",
 438                                RSA_size(prsactx->rsa), tbslen + 1);
 439                 return 0;
 440             }
 441             if (!setup_tbuf(prsactx)) {
 442                 ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 443                 return 0;
 444             }
 445             memcpy(prsactx->tbuf, tbs, tbslen);
 446             prsactx->tbuf[tbslen] = RSA_X931_hash_id(prsactx->mdnid);
 447             ret = RSA_private_encrypt(tbslen + 1, prsactx->tbuf,
 448                                       sig, prsactx->rsa, RSA_X931_PADDING);
 449             clean_tbuf(prsactx);
 450             break;
 451
 452         case RSA_PKCS1_PADDING:
 453             {
 454                 unsigned int sltmp;
 455
 456                 ret = RSA_sign(prsactx->mdnid, tbs, tbslen, sig, &sltmp,
 457                                prsactx->rsa);
 458                 if (ret <= 0) {
 459                     ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 460                     return 0;
 461                 }
 462                 ret = sltmp;
 463             }
 464             break;
 465
 466         case RSA_PKCS1_PSS_PADDING:
 467             /* Check PSS restrictions */
 468             if (rsa_pss_restricted(prsactx)) {
 469                 switch (prsactx->saltlen) {
 470                 case RSA_PSS_SALTLEN_DIGEST:
 471                     if (prsactx->min_saltlen > EVP_MD_size(prsactx->md)) {
 472                         ERR_raise_data(ERR_LIB_PROV,
 473                                        PROV_R_PSS_SALTLEN_TOO_SMALL,
 474                                        "minimum salt length set to %d, "
 475                                        "but the digest only gives %d",
 476                                        prsactx->min_saltlen,
 477                                        EVP_MD_size(prsactx->md));
 478                         return 0;
 479                     }
 480                     /* FALLTHRU */
 481                 default:
 482                     if (prsactx->saltlen >= 0
 483                         && prsactx->saltlen < prsactx->min_saltlen) {
 484                         ERR_raise_data(ERR_LIB_PROV,
 485                                        PROV_R_PSS_SALTLEN_TOO_SMALL,
 486                                        "minimum salt length set to %d, but the"
 487                                        "actual salt length is only set to %d",
 488                                        prsactx->min_saltlen,
 489                                        prsactx->saltlen);
 490                         return 0;
 491                     }
 492                     break;
 493                 }
 494             }
 495             if (!setup_tbuf(prsactx))
 496                 return 0;
 497             if (!RSA_padding_add_PKCS1_PSS_mgf1(prsactx->rsa,
 498                                                 prsactx->tbuf, tbs,
 499                                                 prsactx->md, prsactx->mgf1_md,
 500                                                 prsactx->saltlen)) {
 501                 ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 502                 return 0;
 503             }
 504             ret = RSA_private_encrypt(RSA_size(prsactx->rsa), prsactx->tbuf,
 505                                       sig, prsactx->rsa, RSA_NO_PADDING);
 506             clean_tbuf(prsactx);
 507             break;
 508
 509         default:
 510             ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE,
 511                            "Only X.931, PKCS#1 v1.5 or PSS padding allowed");
 512             return 0;
 513         }
 514     } else {
 515         ret = RSA_private_encrypt(tbslen, tbs, sig, prsactx->rsa,
 516                                   prsactx->pad_mode);
 517     }
 518
 519 #ifndef FIPS_MODULE
 520  end:
 521 #endif
 522     if (ret <= 0) {
 523         ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 524         return 0;
 525     }
 526
 527     *siglen = ret;
 528     return 1;
 529 }
 530
 531 static int rsa_verify_recover_init(void *vprsactx, void *vrsa)
 532 {
 533     return rsa_signature_init(vprsactx, vrsa, EVP_PKEY_OP_VERIFYRECOVER);
 534 }
 535
 536 static int rsa_verify_recover(void *vprsactx,
 537                               unsigned char *rout,
 538                               size_t *routlen,
 539                               size_t routsize,
 540                               const unsigned char *sig,
 541                               size_t siglen)
 542 {
 543     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 544     int ret;
 545
 546     if (rout == NULL) {
 547         *routlen = RSA_size(prsactx->rsa);
 548         return 1;
 549     }
 550
 551     if (prsactx->md != NULL) {
 552         switch (prsactx->pad_mode) {
 553         case RSA_X931_PADDING:
 554             if (!setup_tbuf(prsactx))
 555                 return 0;
 556             ret = RSA_public_decrypt(siglen, sig, prsactx->tbuf, prsactx->rsa,
 557                                      RSA_X931_PADDING);
 558             if (ret < 1) {
 559                 ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 560                 return 0;
 561             }
 562             ret--;
 563             if (prsactx->tbuf[ret] != RSA_X931_hash_id(prsactx->mdnid)) {
 564                 ERR_raise(ERR_LIB_PROV, PROV_R_ALGORITHM_MISMATCH);
 565                 return 0;
 566             }
 567             if (ret != EVP_MD_size(prsactx->md)) {
 568                 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST_LENGTH,
 569                                "Should be %d, but got %d",
 570                                EVP_MD_size(prsactx->md), ret);
 571                 return 0;
 572             }
 573
 574             *routlen = ret;
 575             if (routsize < (size_t)ret) {
 576                 ERR_raise_data(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL,
 577                                "buffer size is %d, should be %d",
 578                                routsize, ret);
 579                 return 0;
 580             }
 581             memcpy(rout, prsactx->tbuf, ret);
 582             break;
 583
 584         case RSA_PKCS1_PADDING:
 585             {
 586                 size_t sltmp;
 587
 588                 ret = int_rsa_verify(prsactx->mdnid, NULL, 0, rout, &sltmp,
 589                                      sig, siglen, prsactx->rsa);
 590                 if (ret <= 0) {
 591                     ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 592                     return 0;
 593                 }
 594                 ret = sltmp;
 595             }
 596             break;
 597
 598         default:
 599             ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE,
 600                            "Only X.931 or PKCS#1 v1.5 padding allowed");
 601             return 0;
 602         }
 603     } else {
 604         ret = RSA_public_decrypt(siglen, sig, rout, prsactx->rsa,
 605                                  prsactx->pad_mode);
 606         if (ret < 0) {
 607             ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 608             return 0;
 609         }
 610     }
 611     *routlen = ret;
 612     return 1;
 613 }
 614
 615 static int rsa_verify_init(void *vprsactx, void *vrsa)
 616 {
 617     return rsa_signature_init(vprsactx, vrsa, EVP_PKEY_OP_VERIFY);
 618 }
 619
 620 static int rsa_verify(void *vprsactx, const unsigned char *sig, size_t siglen,
 621                       const unsigned char *tbs, size_t tbslen)
 622 {
 623     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 624     size_t rslen;
 625
 626     if (prsactx->md != NULL) {
 627         switch (prsactx->pad_mode) {
 628         case RSA_PKCS1_PADDING:
 629             if (!RSA_verify(prsactx->mdnid, tbs, tbslen, sig, siglen,
 630                             prsactx->rsa)) {
 631                 ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 632                 return 0;
 633             }
 634             return 1;
 635         case RSA_X931_PADDING:
 636             if (rsa_verify_recover(prsactx, NULL, &rslen, 0, sig, siglen) <= 0)
 637                 return 0;
 638             break;
 639         case RSA_PKCS1_PSS_PADDING:
 640             {
 641                 int ret;
 642                 size_t mdsize;
 643
 644                 /*
 645                  * We need to check this for the RSA_verify_PKCS1_PSS_mgf1()
 646                  * call
 647                  */
 648                 mdsize = rsa_get_md_size(prsactx);
 649                 if (tbslen != mdsize) {
 650                     ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST_LENGTH,
 651                                    "Should be %d, but got %d",
 652                                    mdsize, tbslen);
 653                     return 0;
 654                 }
 655
 656                 if (!setup_tbuf(prsactx))
 657                     return 0;
 658                 ret = RSA_public_decrypt(siglen, sig, prsactx->tbuf,
 659                                          prsactx->rsa, RSA_NO_PADDING);
 660                 if (ret <= 0) {
 661                     ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 662                     return 0;
 663                 }
 664                 ret = RSA_verify_PKCS1_PSS_mgf1(prsactx->rsa, tbs,
 665                                                 prsactx->md, prsactx->mgf1_md,
 666                                                 prsactx->tbuf,
 667                                                 prsactx->saltlen);
 668                 if (ret <= 0) {
 669                     ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 670                     return 0;
 671                 }
 672                 return 1;
 673             }
 674         default:
 675             ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_PADDING_MODE,
 676                            "Only X.931, PKCS#1 v1.5 or PSS padding allowed");
 677             return 0;
 678         }
 679     } else {
 680         if (!setup_tbuf(prsactx))
 681             return 0;
 682         rslen = RSA_public_decrypt(siglen, sig, prsactx->tbuf, prsactx->rsa,
 683                                    prsactx->pad_mode);
 684         if (rslen == 0) {
 685             ERR_raise(ERR_LIB_PROV, ERR_LIB_RSA);
 686             return 0;
 687         }
 688     }
 689
 690     if ((rslen != tbslen) || memcmp(tbs, prsactx->tbuf, rslen))
 691         return 0;
 692
 693     return 1;
 694 }
 695
 696 static int rsa_digest_signverify_init(void *vprsactx, const char *mdname,
 697                                       void *vrsa, int operation)
 698 {
 699     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 700
 701     prsactx->flag_allow_md = 0;
 702     if (!rsa_signature_init(vprsactx, vrsa, operation)
 703         || !rsa_setup_md(prsactx, mdname, NULL)) /* TODO RL */
 704         return 0;
 705
 706     prsactx->mdctx = EVP_MD_CTX_new();
 707     if (prsactx->mdctx == NULL) {
 708         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 709         goto error;
 710     }
 711
 712     if (!EVP_DigestInit_ex(prsactx->mdctx, prsactx->md, NULL))
 713         goto error;
 714
 715     return 1;
 716
 717  error:
 718     EVP_MD_CTX_free(prsactx->mdctx);
 719     EVP_MD_free(prsactx->md);
 720     prsactx->mdctx = NULL;
 721     prsactx->md = NULL;
 722     return 0;
 723 }
 724
 725 static int rsa_digest_signverify_update(void *vprsactx,
 726                                         const unsigned char *data,
 727                                         size_t datalen)
 728 {
 729     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 730
 731     if (prsactx == NULL || prsactx->mdctx == NULL)
 732         return 0;
 733
 734     return EVP_DigestUpdate(prsactx->mdctx, data, datalen);
 735 }
 736
 737 static int rsa_digest_sign_init(void *vprsactx, const char *mdname,
 738                                 void *vrsa)
 739 {
 740     return rsa_digest_signverify_init(vprsactx, mdname, vrsa,
 741                                       EVP_PKEY_OP_SIGN);
 742 }
 743
 744 static int rsa_digest_sign_final(void *vprsactx, unsigned char *sig,
 745                                  size_t *siglen, size_t sigsize)
 746 {
 747     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 748     unsigned char digest[EVP_MAX_MD_SIZE];
 749     unsigned int dlen = 0;
 750
 751     prsactx->flag_allow_md = 1;
 752     if (prsactx == NULL || prsactx->mdctx == NULL)
 753         return 0;
 754
 755     /*
 756      * If sig is NULL then we're just finding out the sig size. Other fields
 757      * are ignored. Defer to rsa_sign.
 758      */
 759     if (sig != NULL) {
 760         /*
 761          * TODO(3.0): There is the possibility that some externally provided
 762          * digests exceed EVP_MAX_MD_SIZE. We should probably handle that somehow -
 763          * but that problem is much larger than just in RSA.
 764          */
 765         if (!EVP_DigestFinal_ex(prsactx->mdctx, digest, &dlen))
 766             return 0;
 767     }
 768
 769     return rsa_sign(vprsactx, sig, siglen, sigsize, digest, (size_t)dlen);
 770 }
 771
 772 static int rsa_digest_verify_init(void *vprsactx, const char *mdname,
 773                                   void *vrsa)
 774 {
 775     return rsa_digest_signverify_init(vprsactx, mdname, vrsa,
 776                                       EVP_PKEY_OP_VERIFY);
 777 }
 778
 779 int rsa_digest_verify_final(void *vprsactx, const unsigned char *sig,
 780                             size_t siglen)
 781 {
 782     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 783     unsigned char digest[EVP_MAX_MD_SIZE];
 784     unsigned int dlen = 0;
 785
 786     prsactx->flag_allow_md = 1;
 787     if (prsactx == NULL || prsactx->mdctx == NULL)
 788         return 0;
 789
 790     /*
 791      * TODO(3.0): There is the possibility that some externally provided
 792      * digests exceed EVP_MAX_MD_SIZE. We should probably handle that somehow -
 793      * but that problem is much larger than just in RSA.
 794      */
 795     if (!EVP_DigestFinal_ex(prsactx->mdctx, digest, &dlen))
 796         return 0;
 797
 798     return rsa_verify(vprsactx, sig, siglen, digest, (size_t)dlen);
 799 }
 800
 801 static void rsa_freectx(void *vprsactx)
 802 {
 803     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 804
 805     if (prsactx == NULL)
 806         return;
 807
 808     RSA_free(prsactx->rsa);
 809     EVP_MD_CTX_free(prsactx->mdctx);
 810     EVP_MD_free(prsactx->md);
 811     EVP_MD_free(prsactx->mgf1_md);
 812     OPENSSL_free(prsactx->propq);
 813     free_tbuf(prsactx);
 814
 815     OPENSSL_clear_free(prsactx, sizeof(prsactx));
 816 }
 817
 818 static void *rsa_dupctx(void *vprsactx)
 819 {
 820     PROV_RSA_CTX *srcctx = (PROV_RSA_CTX *)vprsactx;
 821     PROV_RSA_CTX *dstctx;
 822
 823     dstctx = OPENSSL_zalloc(sizeof(*srcctx));
 824     if (dstctx == NULL) {
 825         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 826         return NULL;
 827     }
 828
 829     *dstctx = *srcctx;
 830     dstctx->rsa = NULL;
 831     dstctx->md = NULL;
 832     dstctx->mdctx = NULL;
 833     dstctx->tbuf = NULL;
 834
 835     if (srcctx->rsa != NULL && !RSA_up_ref(srcctx->rsa))
 836         goto err;
 837     dstctx->rsa = srcctx->rsa;
 838
 839     if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
 840         goto err;
 841     dstctx->md = srcctx->md;
 842
 843     if (srcctx->mgf1_md != NULL && !EVP_MD_up_ref(srcctx->mgf1_md))
 844         goto err;
 845     dstctx->mgf1_md = srcctx->mgf1_md;
 846
 847     if (srcctx->mdctx != NULL) {
 848         dstctx->mdctx = EVP_MD_CTX_new();
 849         if (dstctx->mdctx == NULL
 850                 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
 851             goto err;
 852     }
 853
 854     return dstctx;
 855  err:
 856     rsa_freectx(dstctx);
 857     return NULL;
 858 }
 859
 860 static int rsa_get_ctx_params(void *vprsactx, OSSL_PARAM *params)
 861 {
 862     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 863     OSSL_PARAM *p;
 864
 865     if (prsactx == NULL || params == NULL)
 866         return 0;
 867
 868     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
 869     if (p != NULL
 870         && !OSSL_PARAM_set_octet_string(p, prsactx->aid, prsactx->aid_len))
 871         return 0;
 872
 873     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_PAD_MODE);
 874     if (p != NULL)
 875         switch (p->data_type) {
 876         case OSSL_PARAM_INTEGER:
 877             if (!OSSL_PARAM_set_int(p, prsactx->pad_mode))
 878                 return 0;
 879             break;
 880         case OSSL_PARAM_UTF8_STRING:
 881             {
 882                 int i;
 883                 const char *word = NULL;
 884
 885                 for (i = 0; padding_item[i].id != 0; i++) {
 886                     if (prsactx->pad_mode == (int)padding_item[i].id) {
 887                         word = padding_item[i].ptr;
 888                         break;
 889                     }
 890                 }
 891
 892                 if (word != NULL) {
 893                     if (!OSSL_PARAM_set_utf8_string(p, word))
 894                         return 0;
 895                 } else {
 896                     ERR_raise(ERR_LIB_PROV, ERR_R_INTERNAL_ERROR);
 897                 }
 898             }
 899             break;
 900         default:
 901             return 0;
 902         }
 903
 904     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
 905     if (p != NULL && !OSSL_PARAM_set_utf8_string(p, prsactx->mdname))
 906         return 0;
 907
 908     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_MGF1_DIGEST);
 909     if (p != NULL && !OSSL_PARAM_set_utf8_string(p, prsactx->mgf1_mdname))
 910         return 0;
 911
 912     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_PSS_SALTLEN);
 913     if (p != NULL) {
 914         if (p->data_type == OSSL_PARAM_INTEGER) {
 915             if (!OSSL_PARAM_set_int(p, prsactx->saltlen))
 916                 return 0;
 917         } else if (p->data_type == OSSL_PARAM_UTF8_STRING) {
 918             switch (prsactx->saltlen) {
 919             case RSA_PSS_SALTLEN_DIGEST:
 920                 if (!OSSL_PARAM_set_utf8_string(p, "digest"))
 921                     return 0;
 922                 break;
 923             case RSA_PSS_SALTLEN_MAX:
 924                 if (!OSSL_PARAM_set_utf8_string(p, "max"))
 925                     return 0;
 926                 break;
 927             case RSA_PSS_SALTLEN_AUTO:
 928                 if (!OSSL_PARAM_set_utf8_string(p, "auto"))
 929                     return 0;
 930                 break;
 931             default:
 932                 if (BIO_snprintf(p->data, p->data_size, "%d", prsactx->saltlen)
 933                     <= 0)
 934                     return 0;
 935                 break;
 936             }
 937         }
 938     }
 939
 940     return 1;
 941 }
 942
 943 static const OSSL_PARAM known_gettable_ctx_params[] = {
 944     OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
 945     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE, NULL, 0),
 946     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
 947     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_MGF1_DIGEST, NULL, 0),
 948     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PSS_SALTLEN, NULL, 0),
 949     OSSL_PARAM_END
 950 };
 951
 952 static const OSSL_PARAM *rsa_gettable_ctx_params(void)
 953 {
 954     return known_gettable_ctx_params;
 955 }
 956
 957 static int rsa_set_ctx_params(void *vprsactx, const OSSL_PARAM params[])
 958 {
 959     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
 960     const OSSL_PARAM *p;
 961
 962     if (prsactx == NULL || params == NULL)
 963         return 0;
 964
 965     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
 966     /* Not allowed during certain operations */
 967     if (p != NULL && !prsactx->flag_allow_md)
 968         return 0;
 969     if (p != NULL) {
 970         char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
 971         char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
 972         const OSSL_PARAM *propsp =
 973             OSSL_PARAM_locate_const(params,
 974                                     OSSL_SIGNATURE_PARAM_PROPERTIES);
 975
 976         if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
 977             return 0;
 978
 979         if (propsp == NULL)
 980             pmdprops = NULL;
 981         else if (!OSSL_PARAM_get_utf8_string(propsp,
 982                                              &pmdprops, sizeof(mdprops)))
 983             return 0;
 984
 985         if (rsa_pss_restricted(prsactx)) {
 986             /* TODO(3.0) figure out what to do for prsactx->md == NULL */
 987             if (prsactx->md == NULL || EVP_MD_is_a(prsactx->md, mdname))
 988                 return 1;
 989             ERR_raise(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED);
 990             return 0;
 991         }
 992
 993         /* non-PSS code follows */
 994         if (!rsa_setup_md(prsactx, mdname, pmdprops))
 995             return 0;
 996     }
 997
 998     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_PAD_MODE);
 999     if (p != NULL) {
1000         int pad_mode = 0;
1001         const char *err_extra_text = NULL;
1002
1003         switch (p->data_type) {
1004         case OSSL_PARAM_INTEGER: /* Support for legacy pad mode number */
1005             if (!OSSL_PARAM_get_int(p, &pad_mode))
1006                 return 0;
1007             break;
1008         case OSSL_PARAM_UTF8_STRING:
1009             {
1010                 int i;
1011
1012                 if (p->data == NULL)
1013                     return 0;
1014
1015                 for (i = 0; padding_item[i].id != 0; i++) {
1016                     if (strcmp(p->data, padding_item[i].ptr) == 0) {
1017                         pad_mode = padding_item[i].id;
1018                         break;
1019                     }
1020                 }
1021             }
1022             break;
1023         default:
1024             return 0;
1025         }
1026
1027         switch (pad_mode) {
1028         case RSA_PKCS1_OAEP_PADDING:
1029             /*
1030              * OAEP padding is for asymmetric cipher only so is not compatible
1031              * with signature use.
1032              */
1033             err_extra_text = "OAEP padding not allowed for signing / verifying";
1034             goto bad_pad;
1035         case RSA_PKCS1_PSS_PADDING:
1036             if ((prsactx->operation
1037                  & (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)) == 0) {
1038                 err_extra_text =
1039                     "PSS padding only allowed for sign and verify operations";
1040                 goto bad_pad;
1041             }
1042             if (prsactx->md == NULL
1043                 && !rsa_setup_md(prsactx, OSSL_DIGEST_NAME_SHA1, NULL)) {
1044                 return 0;
1045             }
1046             break;
1047         case RSA_PKCS1_PADDING:
1048             err_extra_text = "PKCS#1 padding not allowed with RSA-PSS";
1049             goto cont;
1050         case RSA_SSLV23_PADDING:
1051             err_extra_text = "SSLv3 padding not allowed with RSA-PSS";
1052             goto cont;
1053         case RSA_NO_PADDING:
1054             err_extra_text = "No padding not allowed with RSA-PSS";
1055             goto cont;
1056         case RSA_X931_PADDING:
1057             err_extra_text = "X.931 padding not allowed with RSA-PSS";
1058         cont:
1059             if (RSA_test_flags(prsactx->rsa,
1060                                RSA_FLAG_TYPE_MASK) == RSA_FLAG_TYPE_RSA)
1061                 break;
1062             /* FALLTHRU */
1063         default:
1064         bad_pad:
1065             if (err_extra_text == NULL)
1066                 ERR_raise(ERR_LIB_PROV,
1067                           PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
1068             else
1069                 ERR_raise_data(ERR_LIB_PROV,
1070                                PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE,
1071                                err_extra_text);
1072             return 0;
1073         }
1074         if (!rsa_check_padding(prsactx->mdnid, pad_mode))
1075             return 0;
1076         prsactx->pad_mode = pad_mode;
1077     }
1078
1079     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_PSS_SALTLEN);
1080     if (p != NULL) {
1081         int saltlen;
1082
1083         if (prsactx->pad_mode != RSA_PKCS1_PSS_PADDING) {
1084             ERR_raise_data(ERR_LIB_PROV, PROV_R_NOT_SUPPORTED,
1085                            "PSS saltlen can only be specified if "
1086                            "PSS padding has been specified first");
1087             return 0;
1088         }
1089
1090         switch (p->data_type) {
1091         case OSSL_PARAM_INTEGER: /* Support for legacy pad mode number */
1092             if (!OSSL_PARAM_get_int(p, &saltlen))
1093                 return 0;
1094             break;
1095         case OSSL_PARAM_UTF8_STRING:
1096             if (strcmp(p->data, "digest") == 0)
1097                 saltlen = RSA_PSS_SALTLEN_DIGEST;
1098             else if (strcmp(p->data, "max") == 0)
1099                 saltlen = RSA_PSS_SALTLEN_MAX;
1100             else if (strcmp(p->data, "auto") == 0)
1101                 saltlen = RSA_PSS_SALTLEN_AUTO;
1102             else
1103                 saltlen = atoi(p->data);
1104             break;
1105         default:
1106             return 0;
1107         }
1108
1109         /*
1110          * RSA_PSS_SALTLEN_MAX seems curiously named in this check.
1111          * Contrary to what it's name suggests, it's the currently
1112          * lowest saltlen number possible.
1113          */
1114         if (saltlen < RSA_PSS_SALTLEN_MAX) {
1115             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_PSS_SALTLEN);
1116             return 0;
1117         }
1118
1119         if (rsa_pss_restricted(prsactx)) {
1120             switch (prsactx->saltlen) {
1121             case RSA_PSS_SALTLEN_AUTO:
1122                 if (prsactx->operation == EVP_PKEY_OP_VERIFY) {
1123                     ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_PSS_SALTLEN);
1124                     return 0;
1125                 }
1126                 break;
1127             case RSA_PSS_SALTLEN_DIGEST:
1128                 if (prsactx->min_saltlen > EVP_MD_size(prsactx->md)) {
1129                     ERR_raise_data(ERR_LIB_PROV,
1130                                    PROV_R_PSS_SALTLEN_TOO_SMALL,
1131                                    "Should be more than %d, but would be "
1132                                    "set to match digest size (%d)",
1133                                    prsactx->min_saltlen,
1134                                    EVP_MD_size(prsactx->md));
1135                     return 0;
1136                 }
1137                 /* FALLTHRU */
1138             default:
1139                 if (saltlen >= 0 && saltlen < prsactx->min_saltlen) {
1140                     ERR_raise_data(ERR_LIB_PROV,
1141                                    PROV_R_PSS_SALTLEN_TOO_SMALL,
1142                                    "Should be more than %d, "
1143                                    "but would be set to %d",
1144                                    prsactx->min_saltlen, saltlen);
1145                     return 0;
1146                 }
1147             }
1148         }
1149
1150         prsactx->saltlen = saltlen;
1151     }
1152
1153     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_MGF1_DIGEST);
1154     if (p != NULL) {
1155         char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
1156         char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
1157         const OSSL_PARAM *propsp =
1158             OSSL_PARAM_locate_const(params,
1159                                     OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES);
1160
1161         if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
1162             return 0;
1163
1164         if (propsp == NULL)
1165             pmdprops = NULL;
1166         else if (!OSSL_PARAM_get_utf8_string(propsp,
1167                                              &pmdprops, sizeof(mdprops)))
1168             return 0;
1169
1170         if (prsactx->pad_mode != RSA_PKCS1_PSS_PADDING) {
1171             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_MGF1_MD);
1172             return  0;
1173         }
1174
1175         if (rsa_pss_restricted(prsactx)) {
1176             /* TODO(3.0) figure out what to do for prsactx->mgf1_md == NULL */
1177             if (prsactx->mgf1_md == NULL
1178                 || EVP_MD_is_a(prsactx->mgf1_md, mdname))
1179                 return 1;
1180             ERR_raise(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED);
1181             return 0;
1182         }
1183
1184         /* non-PSS code follows */
1185         if (!rsa_setup_mgf1_md(prsactx, mdname, pmdprops))
1186             return 0;
1187     }
1188
1189     return 1;
1190 }
1191
1192 static const OSSL_PARAM known_settable_ctx_params[] = {
1193     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PAD_MODE, NULL, 0),
1194     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
1195     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PROPERTIES, NULL, 0),
1196     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_MGF1_DIGEST, NULL, 0),
1197     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES, NULL, 0),
1198     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PSS_SALTLEN, NULL, 0),
1199     OSSL_PARAM_END
1200 };
1201
1202 static const OSSL_PARAM *rsa_settable_ctx_params(void)
1203 {
1204     /*
1205      * TODO(3.0): Should this function return a different set of settable ctx
1206      * params if the ctx is being used for a DigestSign/DigestVerify? In that
1207      * case it is not allowed to set the digest size/digest name because the
1208      * digest is explicitly set as part of the init.
1209      */
1210     return known_settable_ctx_params;
1211 }
1212
1213 static int rsa_get_ctx_md_params(void *vprsactx, OSSL_PARAM *params)
1214 {
1215     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
1216
1217     if (prsactx->mdctx == NULL)
1218         return 0;
1219
1220     return EVP_MD_CTX_get_params(prsactx->mdctx, params);
1221 }
1222
1223 static const OSSL_PARAM *rsa_gettable_ctx_md_params(void *vprsactx)
1224 {
1225     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
1226
1227     if (prsactx->md == NULL)
1228         return 0;
1229
1230     return EVP_MD_gettable_ctx_params(prsactx->md);
1231 }
1232
1233 static int rsa_set_ctx_md_params(void *vprsactx, const OSSL_PARAM params[])
1234 {
1235     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
1236
1237     if (prsactx->mdctx == NULL)
1238         return 0;
1239
1240     return EVP_MD_CTX_set_params(prsactx->mdctx, params);
1241 }
1242
1243 static const OSSL_PARAM *rsa_settable_ctx_md_params(void *vprsactx)
1244 {
1245     PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
1246
1247     if (prsactx->md == NULL)
1248         return 0;
1249
1250     return EVP_MD_settable_ctx_params(prsactx->md);
1251 }
1252
1253 const OSSL_DISPATCH rsa_signature_functions[] = {
1254     { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))rsa_newctx },
1255     { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))rsa_sign_init },
1256     { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))rsa_sign },
1257     { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))rsa_verify_init },
1258     { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))rsa_verify },
1259     { OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT,
1260       (void (*)(void))rsa_verify_recover_init },
1261     { OSSL_FUNC_SIGNATURE_VERIFY_RECOVER,
1262       (void (*)(void))rsa_verify_recover },
1263     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
1264       (void (*)(void))rsa_digest_sign_init },
1265     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
1266       (void (*)(void))rsa_digest_signverify_update },
1267     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
1268       (void (*)(void))rsa_digest_sign_final },
1269     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
1270       (void (*)(void))rsa_digest_verify_init },
1271     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
1272       (void (*)(void))rsa_digest_signverify_update },
1273     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
1274       (void (*)(void))rsa_digest_verify_final },
1275     { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))rsa_freectx },
1276     { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))rsa_dupctx },
1277     { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))rsa_get_ctx_params },
1278     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
1279       (void (*)(void))rsa_gettable_ctx_params },
1280     { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))rsa_set_ctx_params },
1281     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
1282       (void (*)(void))rsa_settable_ctx_params },
1283     { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
1284       (void (*)(void))rsa_get_ctx_md_params },
1285     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
1286       (void (*)(void))rsa_gettable_ctx_md_params },
1287     { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
1288       (void (*)(void))rsa_set_ctx_md_params },
1289     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
1290       (void (*)(void))rsa_settable_ctx_md_params },
1291     { 0, NULL }
1292 };