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             }
 392             if (p1 == RSA_PKCS1_OAEP_PADDING) {
 393                 if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))
 394                     goto bad_pad;
 395                 if (!rctx->md)
 396                     rctx->md = EVP_sha1();
 397             }
 398             rctx->pad_mode = p1;
 399             return 1;
 400         }
 401  bad_pad:
 402         RSAerr(RSA_F_PKEY_RSA_CTRL,
 403                RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
 404         return -2;
 405
 406     case EVP_PKEY_CTRL_GET_RSA_PADDING:
 407         *(int *)p2 = rctx->pad_mode;
 408         return 1;
 409
 410     case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
 411     case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
 412         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
 413             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
 414             return -2;
 415         }
 416         if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN)
 417             *(int *)p2 = rctx->saltlen;
 418         else {
 419             if (p1 < -2)
 420                 return -2;
 421             rctx->saltlen = p1;
 422         }
 423         return 1;
 424
 425     case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
 426         if (p1 < 512) {
 427             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_KEY_SIZE_TOO_SMALL);
 428             return -2;
 429         }
 430         rctx->nbits = p1;
 431         return 1;
 432
 433     case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
 434         if (p2 == NULL || !BN_is_odd((BIGNUM *)p2) || BN_is_one((BIGNUM *)p2)) {
 435             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_BAD_E_VALUE);
 436             return -2;
 437         }
 438         BN_free(rctx->pub_exp);
 439         rctx->pub_exp = p2;
 440         return 1;
 441
 442     case EVP_PKEY_CTRL_RSA_OAEP_MD:
 443     case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
 444         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 445             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 446             return -2;
 447         }
 448         if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD)
 449             *(const EVP_MD **)p2 = rctx->md;
 450         else
 451             rctx->md = p2;
 452         return 1;
 453
 454     case EVP_PKEY_CTRL_MD:
 455         if (!check_padding_md(p2, rctx->pad_mode))
 456             return 0;
 457         rctx->md = p2;
 458         return 1;
 459
 460     case EVP_PKEY_CTRL_GET_MD:
 461         *(const EVP_MD **)p2 = rctx->md;
 462         return 1;
 463
 464     case EVP_PKEY_CTRL_RSA_MGF1_MD:
 465     case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
 466         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING
 467             && rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 468             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD);
 469             return -2;
 470         }
 471         if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) {
 472             if (rctx->mgf1md)
 473                 *(const EVP_MD **)p2 = rctx->mgf1md;
 474             else
 475                 *(const EVP_MD **)p2 = rctx->md;
 476         } else
 477             rctx->mgf1md = p2;
 478         return 1;
 479
 480     case EVP_PKEY_CTRL_RSA_OAEP_LABEL:
 481         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 482             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 483             return -2;
 484         }
 485         OPENSSL_free(rctx->oaep_label);
 486         if (p2 && p1 > 0) {
 487             rctx->oaep_label = p2;
 488             rctx->oaep_labellen = p1;
 489         } else {
 490             rctx->oaep_label = NULL;
 491             rctx->oaep_labellen = 0;
 492         }
 493         return 1;
 494
 495     case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
 496         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 497             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 498             return -2;
 499         }
 500         *(unsigned char **)p2 = rctx->oaep_label;
 501         return rctx->oaep_labellen;
 502
 503     case EVP_PKEY_CTRL_DIGESTINIT:
 504     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 505     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 506     case EVP_PKEY_CTRL_PKCS7_SIGN:
 507         return 1;
 508 #ifndef OPENSSL_NO_CMS
 509     case EVP_PKEY_CTRL_CMS_DECRYPT:
 510     case EVP_PKEY_CTRL_CMS_ENCRYPT:
 511     case EVP_PKEY_CTRL_CMS_SIGN:
 512         return 1;
 513 #endif
 514     case EVP_PKEY_CTRL_PEER_KEY:
 515         RSAerr(RSA_F_PKEY_RSA_CTRL,
 516                RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 517         return -2;
 518
 519     default:
 520         return -2;
 521
 522     }
 523 }
 524
 525 static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 526                              const char *type, const char *value)
 527 {
 528     if (!value) {
 529         RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
 530         return 0;
 531     }
 532     if (strcmp(type, "rsa_padding_mode") == 0) {
 533         int pm;
 534         if (strcmp(value, "pkcs1") == 0)
 535             pm = RSA_PKCS1_PADDING;
 536         else if (strcmp(value, "sslv23") == 0)
 537             pm = RSA_SSLV23_PADDING;
 538         else if (strcmp(value, "none") == 0)
 539             pm = RSA_NO_PADDING;
 540         else if (strcmp(value, "oeap") == 0)
 541             pm = RSA_PKCS1_OAEP_PADDING;
 542         else if (strcmp(value, "oaep") == 0)
 543             pm = RSA_PKCS1_OAEP_PADDING;
 544         else if (strcmp(value, "x931") == 0)
 545             pm = RSA_X931_PADDING;
 546         else if (strcmp(value, "pss") == 0)
 547             pm = RSA_PKCS1_PSS_PADDING;
 548         else {
 549             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_UNKNOWN_PADDING_TYPE);
 550             return -2;
 551         }
 552         return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
 553     }
 554
 555     if (strcmp(type, "rsa_pss_saltlen") == 0) {
 556         int saltlen;
 557         saltlen = atoi(value);
 558         return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
 559     }
 560
 561     if (strcmp(type, "rsa_keygen_bits") == 0) {
 562         int nbits;
 563         nbits = atoi(value);
 564         return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits);
 565     }
 566
 567     if (strcmp(type, "rsa_keygen_pubexp") == 0) {
 568         int ret;
 569         BIGNUM *pubexp = NULL;
 570         if (!BN_asc2bn(&pubexp, value))
 571             return 0;
 572         ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
 573         if (ret <= 0)
 574             BN_free(pubexp);
 575         return ret;
 576     }
 577
 578     if (strcmp(type, "rsa_mgf1_md") == 0)
 579         return EVP_PKEY_CTX_md(ctx,
 580                                EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
 581                                EVP_PKEY_CTRL_RSA_MGF1_MD, value);
 582
 583     if (strcmp(type, "rsa_oaep_md") == 0) {
 584         const EVP_MD *md;
 585         if ((md = EVP_get_digestbyname(value)) == NULL) {
 586             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_INVALID_DIGEST);
 587             return 0;
 588         }
 589     }
 590
 591     if (strcmp(type, "rsa_oaep_md") == 0)
 592         return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_CRYPT,
 593                                EVP_PKEY_CTRL_RSA_OAEP_MD, value);
 594
 595     if (strcmp(type, "rsa_oaep_label") == 0) {
 596         unsigned char *lab;
 597         long lablen;
 598         int ret;
 599         lab = OPENSSL_hexstr2buf(value, &lablen);
 600         if (!lab)
 601             return 0;
 602         ret = EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, lab, lablen);
 603         if (ret <= 0)
 604             OPENSSL_free(lab);
 605         return ret;
 606     }
 607
 608     return -2;
 609 }
 610
 611 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 612 {
 613     RSA *rsa = NULL;
 614     RSA_PKEY_CTX *rctx = ctx->data;
 615     BN_GENCB *pcb;
 616     int ret;
 617     if (rctx->pub_exp == NULL) {
 618         rctx->pub_exp = BN_new();
 619         if (rctx->pub_exp == NULL || !BN_set_word(rctx->pub_exp, RSA_F4))
 620             return 0;
 621     }
 622     rsa = RSA_new();
 623     if (rsa == NULL)
 624         return 0;
 625     if (ctx->pkey_gencb) {
 626         pcb = BN_GENCB_new();
 627         if (pcb == NULL) {
 628             RSA_free(rsa);
 629             return 0;
 630         }
 631         evp_pkey_set_cb_translate(pcb, ctx);
 632     } else
 633         pcb = NULL;
 634     ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
 635     BN_GENCB_free(pcb);
 636     if (ret > 0)
 637         EVP_PKEY_assign(pkey, ctx->pmeth->pkey_id, rsa);
 638     else
 639         RSA_free(rsa);
 640     return ret;
 641 }
 642
 643 const EVP_PKEY_METHOD rsa_pkey_meth = {
 644     EVP_PKEY_RSA,
 645     EVP_PKEY_FLAG_AUTOARGLEN,
 646     pkey_rsa_init,
 647     pkey_rsa_copy,
 648     pkey_rsa_cleanup,
 649
 650     0, 0,
 651
 652     0,
 653     pkey_rsa_keygen,
 654
 655     0,
 656     pkey_rsa_sign,
 657
 658     0,
 659     pkey_rsa_verify,
 660
 661     0,
 662     pkey_rsa_verifyrecover,
 663
 664     0, 0, 0, 0,
 665
 666     0,
 667     pkey_rsa_encrypt,
 668
 669     0,
 670     pkey_rsa_decrypt,
 671
 672     0, 0,
 673
 674     pkey_rsa_ctrl,
 675     pkey_rsa_ctrl_str
 676 };
 677
 678 const EVP_PKEY_METHOD rsa_pss_pkey_meth = {
 679     EVP_PKEY_RSA_PSS,
 680     EVP_PKEY_FLAG_AUTOARGLEN,
 681     pkey_rsa_init,
 682     pkey_rsa_copy,
 683     pkey_rsa_cleanup,
 684
 685     0, 0,
 686
 687     0,
 688     pkey_rsa_keygen,
 689
 690     0,
 691     pkey_rsa_sign,
 692
 693     0,
 694     pkey_rsa_verify,
 695
 696     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 697
 698     pkey_rsa_ctrl,
 699     pkey_rsa_ctrl_str
 700 };