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