crypto/rsa/rsa_pmeth.c

   1 /*
   2  * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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 #include <stdio.h>
  11 #include "internal/cryptlib.h"
  12 #include <openssl/asn1t.h>
  13 #include <openssl/x509.h>
  14 #include <openssl/rsa.h>
  15 #include <openssl/bn.h>
  16 #include <openssl/evp.h>
  17 #include <openssl/x509v3.h>
  18 #include <openssl/cms.h>
  19 #include "internal/evp_int.h"
  20 #include "rsa_locl.h"
  21
  22 /* RSA pkey context structure */
  23
  24 typedef struct {
  25     /* Key gen parameters */
  26     int nbits;
  27     BIGNUM *pub_exp;
  28     /* Keygen callback info */
  29     int gentmp[2];
  30     /* RSA padding mode */
  31     int pad_mode;
  32     /* message digest */
  33     const EVP_MD *md;
  34     /* message digest for MGF1 */
  35     const EVP_MD *mgf1md;
  36     /* PSS salt length */
  37     int saltlen;
  38     /* Temp buffer */
  39     unsigned char *tbuf;
  40     /* OAEP label */
  41     unsigned char *oaep_label;
  42     size_t oaep_labellen;
  43 } RSA_PKEY_CTX;
  44
  45 static int pkey_rsa_init(EVP_PKEY_CTX *ctx)
  46 {
  47     RSA_PKEY_CTX *rctx;
  48     rctx = OPENSSL_zalloc(sizeof(*rctx));
  49     if (rctx == NULL)
  50         return 0;
  51     rctx->nbits = 1024;
  52     if (ctx->pmeth->pkey_id == EVP_PKEY_RSA_PSS)
  53         rctx->pad_mode = RSA_PKCS1_PSS_PADDING;
  54     else
  55         rctx->pad_mode = RSA_PKCS1_PADDING;
  56     rctx->saltlen = -2;
  57     ctx->data = rctx;
  58     ctx->keygen_info = rctx->gentmp;
  59     ctx->keygen_info_count = 2;
  60
  61     return 1;
  62 }
  63
  64 static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
  65 {
  66     RSA_PKEY_CTX *dctx, *sctx;
  67     if (!pkey_rsa_init(dst))
  68         return 0;
  69     sctx = src->data;
  70     dctx = dst->data;
  71     dctx->nbits = sctx->nbits;
  72     if (sctx->pub_exp) {
  73         dctx->pub_exp = BN_dup(sctx->pub_exp);
  74         if (!dctx->pub_exp)
  75             return 0;
  76     }
  77     dctx->pad_mode = sctx->pad_mode;
  78     dctx->md = sctx->md;
  79     dctx->mgf1md = sctx->mgf1md;
  80     if (sctx->oaep_label) {
  81         OPENSSL_free(dctx->oaep_label);
  82         dctx->oaep_label = OPENSSL_memdup(sctx->oaep_label, sctx->oaep_labellen);
  83         if (!dctx->oaep_label)
  84             return 0;
  85         dctx->oaep_labellen = sctx->oaep_labellen;
  86     }
  87     return 1;
  88 }
  89
  90 static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk)
  91 {
  92     if (ctx->tbuf)
  93         return 1;
  94     ctx->tbuf = OPENSSL_malloc(EVP_PKEY_size(pk->pkey));
  95     if (ctx->tbuf == NULL)
  96         return 0;
  97     return 1;
  98 }
  99
 100 static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx)
 101 {
 102     RSA_PKEY_CTX *rctx = ctx->data;
 103     if (rctx) {
 104         BN_free(rctx->pub_exp);
 105         OPENSSL_free(rctx->tbuf);
 106         OPENSSL_free(rctx->oaep_label);
 107         OPENSSL_free(rctx);
 108     }
 109 }
 110
 111 static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig,
 112                          size_t *siglen, const unsigned char *tbs,
 113                          size_t tbslen)
 114 {
 115     int ret;
 116     RSA_PKEY_CTX *rctx = ctx->data;
 117     RSA *rsa = ctx->pkey->pkey.rsa;
 118
 119     if (rctx->md) {
 120         if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
 121             RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_INVALID_DIGEST_LENGTH);
 122             return -1;
 123         }
 124
 125         if (EVP_MD_type(rctx->md) == NID_mdc2) {
 126             unsigned int sltmp;
 127             if (rctx->pad_mode != RSA_PKCS1_PADDING)
 128                 return -1;
 129             ret = RSA_sign_ASN1_OCTET_STRING(0,
 130                                              tbs, tbslen, sig, &sltmp, rsa);
 131
 132             if (ret <= 0)
 133                 return ret;
 134             ret = sltmp;
 135         } else if (rctx->pad_mode == RSA_X931_PADDING) {
 136             if ((size_t)EVP_PKEY_size(ctx->pkey) < tbslen + 1) {
 137                 RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_KEY_SIZE_TOO_SMALL);
 138                 return -1;
 139             }
 140             if (!setup_tbuf(rctx, ctx)) {
 141                 RSAerr(RSA_F_PKEY_RSA_SIGN, ERR_R_MALLOC_FAILURE);
 142                 return -1;
 143             }
 144             memcpy(rctx->tbuf, tbs, tbslen);
 145             rctx->tbuf[tbslen] = RSA_X931_hash_id(EVP_MD_type(rctx->md));
 146             ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf,
 147                                       sig, rsa, RSA_X931_PADDING);
 148         } else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
 149             unsigned int sltmp;
 150             ret = RSA_sign(EVP_MD_type(rctx->md),
 151                            tbs, tbslen, sig, &sltmp, rsa);
 152             if (ret <= 0)
 153                 return ret;
 154             ret = sltmp;
 155         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 156             if (!setup_tbuf(rctx, ctx))
 157                 return -1;
 158             if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa,
 159                                                 rctx->tbuf, tbs,
 160                                                 rctx->md, rctx->mgf1md,
 161                                                 rctx->saltlen))
 162                 return -1;
 163             ret = RSA_private_encrypt(RSA_size(rsa), rctx->tbuf,
 164                                       sig, rsa, RSA_NO_PADDING);
 165         } else
 166             return -1;
 167     } else
 168         ret = RSA_private_encrypt(tbslen, tbs, sig, ctx->pkey->pkey.rsa,
 169                                   rctx->pad_mode);
 170     if (ret < 0)
 171         return ret;
 172     *siglen = ret;
 173     return 1;
 174 }
 175
 176 static int pkey_rsa_verifyrecover(EVP_PKEY_CTX *ctx,
 177                                   unsigned char *rout, size_t *routlen,
 178                                   const unsigned char *sig, size_t siglen)
 179 {
 180     int ret;
 181     RSA_PKEY_CTX *rctx = ctx->data;
 182
 183     if (rctx->md) {
 184         if (rctx->pad_mode == RSA_X931_PADDING) {
 185             if (!setup_tbuf(rctx, ctx))
 186                 return -1;
 187             ret = RSA_public_decrypt(siglen, sig,
 188                                      rctx->tbuf, ctx->pkey->pkey.rsa,
 189                                      RSA_X931_PADDING);
 190             if (ret < 1)
 191                 return 0;
 192             ret--;
 193             if (rctx->tbuf[ret] != RSA_X931_hash_id(EVP_MD_type(rctx->md))) {
 194                 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
 195                        RSA_R_ALGORITHM_MISMATCH);
 196                 return 0;
 197             }
 198             if (ret != EVP_MD_size(rctx->md)) {
 199                 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
 200                        RSA_R_INVALID_DIGEST_LENGTH);
 201                 return 0;
 202             }
 203             if (rout)
 204                 memcpy(rout, rctx->tbuf, ret);
 205         } else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
 206             size_t sltmp;
 207             ret = int_rsa_verify(EVP_MD_type(rctx->md),
 208                                  NULL, 0, rout, &sltmp,
 209                                  sig, siglen, ctx->pkey->pkey.rsa);
 210             if (ret <= 0)
 211                 return 0;
 212             ret = sltmp;
 213         } else
 214             return -1;
 215     } else
 216         ret = RSA_public_decrypt(siglen, sig, rout, ctx->pkey->pkey.rsa,
 217                                  rctx->pad_mode);
 218     if (ret < 0)
 219         return ret;
 220     *routlen = ret;
 221     return 1;
 222 }
 223
 224 static int pkey_rsa_verify(EVP_PKEY_CTX *ctx,
 225                            const unsigned char *sig, size_t siglen,
 226                            const unsigned char *tbs, size_t tbslen)
 227 {
 228     RSA_PKEY_CTX *rctx = ctx->data;
 229     RSA *rsa = ctx->pkey->pkey.rsa;
 230     size_t rslen;
 231     if (rctx->md) {
 232         if (rctx->pad_mode == RSA_PKCS1_PADDING)
 233             return RSA_verify(EVP_MD_type(rctx->md), tbs, tbslen,
 234                               sig, siglen, rsa);
 235         if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
 236             RSAerr(RSA_F_PKEY_RSA_VERIFY, RSA_R_INVALID_DIGEST_LENGTH);
 237             return -1;
 238         }
 239         if (rctx->pad_mode == RSA_X931_PADDING) {
 240             if (pkey_rsa_verifyrecover(ctx, NULL, &rslen, sig, siglen) <= 0)
 241                 return 0;
 242         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 243             int ret;
 244             if (!setup_tbuf(rctx, ctx))
 245                 return -1;
 246             ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
 247                                      rsa, RSA_NO_PADDING);
 248             if (ret <= 0)
 249                 return 0;
 250             ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs,
 251                                             rctx->md, rctx->mgf1md,
 252                                             rctx->tbuf, rctx->saltlen);
 253             if (ret <= 0)
 254                 return 0;
 255             return 1;
 256         } else
 257             return -1;
 258     } else {
 259         if (!setup_tbuf(rctx, ctx))
 260             return -1;
 261         rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf,
 262                                    rsa, rctx->pad_mode);
 263         if (rslen == 0)
 264             return 0;
 265     }
 266
 267     if ((rslen != tbslen) || memcmp(tbs, rctx->tbuf, rslen))
 268         return 0;
 269
 270     return 1;
 271
 272 }
 273
 274 static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx,
 275                             unsigned char *out, size_t *outlen,
 276                             const unsigned char *in, size_t inlen)
 277 {
 278     int ret;
 279     RSA_PKEY_CTX *rctx = ctx->data;
 280     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
 281         int klen = RSA_size(ctx->pkey->pkey.rsa);
 282         if (!setup_tbuf(rctx, ctx))
 283             return -1;
 284         if (!RSA_padding_add_PKCS1_OAEP_mgf1(rctx->tbuf, klen,
 285                                              in, inlen,
 286                                              rctx->oaep_label,
 287                                              rctx->oaep_labellen,
 288                                              rctx->md, rctx->mgf1md))
 289             return -1;
 290         ret = RSA_public_encrypt(klen, rctx->tbuf, out,
 291                                  ctx->pkey->pkey.rsa, RSA_NO_PADDING);
 292     } else
 293         ret = RSA_public_encrypt(inlen, in, out, ctx->pkey->pkey.rsa,
 294                                  rctx->pad_mode);
 295     if (ret < 0)
 296         return ret;
 297     *outlen = ret;
 298     return 1;
 299 }
 300
 301 static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx,
 302                             unsigned char *out, size_t *outlen,
 303                             const unsigned char *in, size_t inlen)
 304 {
 305     int ret;
 306     RSA_PKEY_CTX *rctx = ctx->data;
 307     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
 308         int i;
 309         if (!setup_tbuf(rctx, ctx))
 310             return -1;
 311         ret = RSA_private_decrypt(inlen, in, rctx->tbuf,
 312                                   ctx->pkey->pkey.rsa, RSA_NO_PADDING);
 313         if (ret <= 0)
 314             return ret;
 315         for (i = 0; i < ret; i++) {
 316             if (rctx->tbuf[i])
 317                 break;
 318         }
 319         ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, ret, rctx->tbuf + i,
 320                                                 ret - i, ret,
 321                                                 rctx->oaep_label,
 322                                                 rctx->oaep_labellen,
 323                                                 rctx->md, rctx->mgf1md);
 324     } else
 325         ret = RSA_private_decrypt(inlen, in, out, ctx->pkey->pkey.rsa,
 326                                   rctx->pad_mode);
 327     if (ret < 0)
 328         return ret;
 329     *outlen = ret;
 330     return 1;
 331 }
 332
 333 static int check_padding_md(const EVP_MD *md, int padding)
 334 {
 335     int mdnid;
 336     if (!md)
 337         return 1;
 338
 339     mdnid = EVP_MD_type(md);
 340
 341     if (padding == RSA_NO_PADDING) {
 342         RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_PADDING_MODE);
 343         return 0;
 344     }
 345
 346     if (padding == RSA_X931_PADDING) {
 347         if (RSA_X931_hash_id(mdnid) == -1) {
 348             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_X931_DIGEST);
 349             return 0;
 350         }
 351     } else {
 352         switch(mdnid) {
 353         /* List of all supported RSA digests */
 354         case NID_sha1:
 355         case NID_sha224:
 356         case NID_sha256:
 357         case NID_sha384:
 358         case NID_sha512:
 359         case NID_md5:
 360         case NID_md5_sha1:
 361         case NID_md2:
 362         case NID_md4:
 363         case NID_mdc2:
 364         case NID_ripemd160:
 365             return 1;
 366
 367         default:
 368             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_DIGEST);
 369             return 0;
 370
 371         }
 372     }
 373
 374     return 1;
 375 }
 376
 377 static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 378 {
 379     RSA_PKEY_CTX *rctx = ctx->data;
 380     switch (type) {
 381     case EVP_PKEY_CTRL_RSA_PADDING:
 382         if ((p1 >= RSA_PKCS1_PADDING) && (p1 <= RSA_PKCS1_PSS_PADDING)) {
 383             if (!check_padding_md(rctx->md, p1))
 384                 return 0;
 385             if (p1 == RSA_PKCS1_PSS_PADDING) {
 386                 if (!(ctx->operation &
 387                       (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)))
 388                     goto bad_pad;
 389                 if (!rctx->md)
 390                     rctx->md = EVP_sha1();
 391             } else if (ctx->pmeth->pkey_id == EVP_PKEY_RSA_PSS) {
 392                 goto bad_pad;
 393             }
 394             if (p1 == RSA_PKCS1_OAEP_PADDING) {
 395                 if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))
 396                     goto bad_pad;
 397                 if (!rctx->md)
 398                     rctx->md = EVP_sha1();
 399             }
 400             rctx->pad_mode = p1;
 401             return 1;
 402         }
 403  bad_pad:
 404         RSAerr(RSA_F_PKEY_RSA_CTRL,
 405                RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
 406         return -2;
 407
 408     case EVP_PKEY_CTRL_GET_RSA_PADDING:
 409         *(int *)p2 = rctx->pad_mode;
 410         return 1;
 411
 412     case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
 413     case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
 414         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
 415             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
 416             return -2;
 417         }
 418         if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN)
 419             *(int *)p2 = rctx->saltlen;
 420         else {
 421             if (p1 < -2)
 422                 return -2;
 423             rctx->saltlen = p1;
 424         }
 425         return 1;
 426
 427     case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
 428         if (p1 < 512) {
 429             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_KEY_SIZE_TOO_SMALL);
 430             return -2;
 431         }
 432         rctx->nbits = p1;
 433         return 1;
 434
 435     case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
 436         if (p2 == NULL || !BN_is_odd((BIGNUM *)p2) || BN_is_one((BIGNUM *)p2)) {
 437             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_BAD_E_VALUE);
 438             return -2;
 439         }
 440         BN_free(rctx->pub_exp);
 441         rctx->pub_exp = p2;
 442         return 1;
 443
 444     case EVP_PKEY_CTRL_RSA_OAEP_MD:
 445     case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
 446         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 447             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 448             return -2;
 449         }
 450         if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD)
 451             *(const EVP_MD **)p2 = rctx->md;
 452         else
 453             rctx->md = p2;
 454         return 1;
 455
 456     case EVP_PKEY_CTRL_MD:
 457         if (!check_padding_md(p2, rctx->pad_mode))
 458             return 0;
 459         rctx->md = p2;
 460         return 1;
 461
 462     case EVP_PKEY_CTRL_GET_MD:
 463         *(const EVP_MD **)p2 = rctx->md;
 464         return 1;
 465
 466     case EVP_PKEY_CTRL_RSA_MGF1_MD:
 467     case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
 468         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING
 469             && rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 470             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD);
 471             return -2;
 472         }
 473         if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) {
 474             if (rctx->mgf1md)
 475                 *(const EVP_MD **)p2 = rctx->mgf1md;
 476             else
 477                 *(const EVP_MD **)p2 = rctx->md;
 478         } else
 479             rctx->mgf1md = p2;
 480         return 1;
 481
 482     case EVP_PKEY_CTRL_RSA_OAEP_LABEL:
 483         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 484             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 485             return -2;
 486         }
 487         OPENSSL_free(rctx->oaep_label);
 488         if (p2 && p1 > 0) {
 489             rctx->oaep_label = p2;
 490             rctx->oaep_labellen = p1;
 491         } else {
 492             rctx->oaep_label = NULL;
 493             rctx->oaep_labellen = 0;
 494         }
 495         return 1;
 496
 497     case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
 498         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 499             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 500             return -2;
 501         }
 502         *(unsigned char **)p2 = rctx->oaep_label;
 503         return rctx->oaep_labellen;
 504
 505     case EVP_PKEY_CTRL_DIGESTINIT:
 506     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 507     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 508     case EVP_PKEY_CTRL_PKCS7_SIGN:
 509         return 1;
 510 #ifndef OPENSSL_NO_CMS
 511     case EVP_PKEY_CTRL_CMS_DECRYPT:
 512     case EVP_PKEY_CTRL_CMS_ENCRYPT:
 513     case EVP_PKEY_CTRL_CMS_SIGN:
 514         return 1;
 515 #endif
 516     case EVP_PKEY_CTRL_PEER_KEY:
 517         RSAerr(RSA_F_PKEY_RSA_CTRL,
 518                RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 519         return -2;
 520
 521     default:
 522         return -2;
 523
 524     }
 525 }
 526
 527 static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 528                              const char *type, const char *value)
 529 {
 530     if (!value) {
 531         RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
 532         return 0;
 533     }
 534     if (strcmp(type, "rsa_padding_mode") == 0) {
 535         int pm;
 536         if (strcmp(value, "pkcs1") == 0)
 537             pm = RSA_PKCS1_PADDING;
 538         else if (strcmp(value, "sslv23") == 0)
 539             pm = RSA_SSLV23_PADDING;
 540         else if (strcmp(value, "none") == 0)
 541             pm = RSA_NO_PADDING;
 542         else if (strcmp(value, "oeap") == 0)
 543             pm = RSA_PKCS1_OAEP_PADDING;
 544         else if (strcmp(value, "oaep") == 0)
 545             pm = RSA_PKCS1_OAEP_PADDING;
 546         else if (strcmp(value, "x931") == 0)
 547             pm = RSA_X931_PADDING;
 548         else if (strcmp(value, "pss") == 0)
 549             pm = RSA_PKCS1_PSS_PADDING;
 550         else {
 551             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_UNKNOWN_PADDING_TYPE);
 552             return -2;
 553         }
 554         return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
 555     }
 556
 557     if (strcmp(type, "rsa_pss_saltlen") == 0) {
 558         int saltlen;
 559         saltlen = atoi(value);
 560         return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
 561     }
 562
 563     if (strcmp(type, "rsa_keygen_bits") == 0) {
 564         int nbits;
 565         nbits = atoi(value);
 566         return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits);
 567     }
 568
 569     if (strcmp(type, "rsa_keygen_pubexp") == 0) {
 570         int ret;
 571         BIGNUM *pubexp = NULL;
 572         if (!BN_asc2bn(&pubexp, value))
 573             return 0;
 574         ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
 575         if (ret <= 0)
 576             BN_free(pubexp);
 577         return ret;
 578     }
 579
 580     if (strcmp(type, "rsa_mgf1_md") == 0)
 581         return EVP_PKEY_CTX_md(ctx,
 582                                EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
 583                                EVP_PKEY_CTRL_RSA_MGF1_MD, value);
 584
 585     if (ctx->pmeth->pkey_id == EVP_PKEY_RSA_PSS) {
 586
 587         if (strcmp(type, "rsa_pss_keygen_mgf1_md") == 0)
 588             return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_KEYGEN,
 589                                    EVP_PKEY_CTRL_RSA_MGF1_MD, value);
 590
 591         if (strcmp(type, "rsa_pss_keygen_md") == 0)
 592             return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_KEYGEN,
 593                                    EVP_PKEY_CTRL_MD, value);
 594
 595         if (strcmp(type, "rsa_pss_keygen_saltlen") == 0) {
 596             int saltlen;
 597             saltlen = atoi(value);
 598             return EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(ctx, saltlen);
 599         }
 600     }
 601
 602     if (strcmp(type, "rsa_oaep_md") == 0)
 603         return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_CRYPT,
 604                                EVP_PKEY_CTRL_RSA_OAEP_MD, value);
 605
 606     if (strcmp(type, "rsa_oaep_label") == 0) {
 607         unsigned char *lab;
 608         long lablen;
 609         int ret;
 610         lab = OPENSSL_hexstr2buf(value, &lablen);
 611         if (!lab)
 612             return 0;
 613         ret = EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, lab, lablen);
 614         if (ret <= 0)
 615             OPENSSL_free(lab);
 616         return ret;
 617     }
 618
 619     return -2;
 620 }
 621
 622 /* Set PSS parameters when generating a key, if necessary */
 623 static int rsa_set_pss_param(RSA *rsa, EVP_PKEY_CTX *ctx)
 624 {
 625     RSA_PKEY_CTX *rctx = ctx->data;
 626     if (ctx->pmeth->pkey_id != EVP_PKEY_RSA_PSS)
 627         return 1;
 628     if (rctx->md == NULL && rctx->mgf1md == NULL && rctx->saltlen == -2)
 629         return 1;
 630     rsa->pss = rsa_pss_params_create(rctx->md, rctx->mgf1md,
 631                                      rctx->saltlen == -2 ? 0 : rctx->saltlen);
 632     if (rsa->pss == NULL)
 633         return 0;
 634     return 1;
 635 }
 636
 637 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 638 {
 639     RSA *rsa = NULL;
 640     RSA_PKEY_CTX *rctx = ctx->data;
 641     BN_GENCB *pcb;
 642     int ret;
 643     if (rctx->pub_exp == NULL) {
 644         rctx->pub_exp = BN_new();
 645         if (rctx->pub_exp == NULL || !BN_set_word(rctx->pub_exp, RSA_F4))
 646             return 0;
 647     }
 648     rsa = RSA_new();
 649     if (rsa == NULL)
 650         return 0;
 651     if (ctx->pkey_gencb) {
 652         pcb = BN_GENCB_new();
 653         if (pcb == NULL) {
 654             RSA_free(rsa);
 655             return 0;
 656         }
 657         evp_pkey_set_cb_translate(pcb, ctx);
 658     } else
 659         pcb = NULL;
 660     ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
 661     BN_GENCB_free(pcb);
 662     if (ret > 0 && !rsa_set_pss_param(rsa, ctx)) {
 663         RSA_free(rsa);
 664         return 0;
 665     }
 666     if (ret > 0)
 667         EVP_PKEY_assign(pkey, ctx->pmeth->pkey_id, rsa);
 668     else
 669         RSA_free(rsa);
 670     return ret;
 671 }
 672
 673 const EVP_PKEY_METHOD rsa_pkey_meth = {
 674     EVP_PKEY_RSA,
 675     EVP_PKEY_FLAG_AUTOARGLEN,
 676     pkey_rsa_init,
 677     pkey_rsa_copy,
 678     pkey_rsa_cleanup,
 679
 680     0, 0,
 681
 682     0,
 683     pkey_rsa_keygen,
 684
 685     0,
 686     pkey_rsa_sign,
 687
 688     0,
 689     pkey_rsa_verify,
 690
 691     0,
 692     pkey_rsa_verifyrecover,
 693
 694     0, 0, 0, 0,
 695
 696     0,
 697     pkey_rsa_encrypt,
 698
 699     0,
 700     pkey_rsa_decrypt,
 701
 702     0, 0,
 703
 704     pkey_rsa_ctrl,
 705     pkey_rsa_ctrl_str
 706 };
 707
 708 const EVP_PKEY_METHOD rsa_pss_pkey_meth = {
 709     EVP_PKEY_RSA_PSS,
 710     EVP_PKEY_FLAG_AUTOARGLEN,
 711     pkey_rsa_init,
 712     pkey_rsa_copy,
 713     pkey_rsa_cleanup,
 714
 715     0, 0,
 716
 717     0,
 718     pkey_rsa_keygen,
 719
 720     0,
 721     pkey_rsa_sign,
 722
 723     0,
 724     pkey_rsa_verify,
 725
 726     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 727
 728     pkey_rsa_ctrl,
 729     pkey_rsa_ctrl_str
 730 };