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