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 (tbslen != (size_t)EVP_MD_size(rctx->md)) {
 233             RSAerr(RSA_F_PKEY_RSA_VERIFY, RSA_R_INVALID_DIGEST_LENGTH);
 234             return -1;
 235         }
 236         if (rctx->pad_mode == RSA_X931_PADDING) {
 237             if (pkey_rsa_verifyrecover(ctx, NULL, &rslen, sig, siglen) <= 0)
 238                 return 0;
 239         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 240             int ret;
 241             if (!setup_tbuf(rctx, ctx))
 242                 return -1;
 243             ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
 244                                      rsa, RSA_NO_PADDING);
 245             if (ret <= 0)
 246                 return 0;
 247             ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs,
 248                                             rctx->md, rctx->mgf1md,
 249                                             rctx->tbuf, rctx->saltlen);
 250             if (ret <= 0)
 251                 return 0;
 252             return 1;
 253         } else
 254             return -1;
 255     } else {
 256         if (!setup_tbuf(rctx, ctx))
 257             return -1;
 258         rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf,
 259                                    rsa, rctx->pad_mode);
 260         if (rslen == 0)
 261             return 0;
 262     }
 263
 264     if ((rslen != tbslen) || memcmp(tbs, rctx->tbuf, rslen))
 265         return 0;
 266
 267     return 1;
 268
 269 }
 270
 271 static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx,
 272                             unsigned char *out, size_t *outlen,
 273                             const unsigned char *in, size_t inlen)
 274 {
 275     int ret;
 276     RSA_PKEY_CTX *rctx = ctx->data;
 277     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
 278         int klen = RSA_size(ctx->pkey->pkey.rsa);
 279         if (!setup_tbuf(rctx, ctx))
 280             return -1;
 281         if (!RSA_padding_add_PKCS1_OAEP_mgf1(rctx->tbuf, klen,
 282                                              in, inlen,
 283                                              rctx->oaep_label,
 284                                              rctx->oaep_labellen,
 285                                              rctx->md, rctx->mgf1md))
 286             return -1;
 287         ret = RSA_public_encrypt(klen, rctx->tbuf, out,
 288                                  ctx->pkey->pkey.rsa, RSA_NO_PADDING);
 289     } else
 290         ret = RSA_public_encrypt(inlen, in, out, ctx->pkey->pkey.rsa,
 291                                  rctx->pad_mode);
 292     if (ret < 0)
 293         return ret;
 294     *outlen = ret;
 295     return 1;
 296 }
 297
 298 static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx,
 299                             unsigned char *out, size_t *outlen,
 300                             const unsigned char *in, size_t inlen)
 301 {
 302     int ret;
 303     RSA_PKEY_CTX *rctx = ctx->data;
 304     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
 305         int i;
 306         if (!setup_tbuf(rctx, ctx))
 307             return -1;
 308         ret = RSA_private_decrypt(inlen, in, rctx->tbuf,
 309                                   ctx->pkey->pkey.rsa, RSA_NO_PADDING);
 310         if (ret <= 0)
 311             return ret;
 312         for (i = 0; i < ret; i++) {
 313             if (rctx->tbuf[i])
 314                 break;
 315         }
 316         ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, ret, rctx->tbuf + i,
 317                                                 ret - i, ret,
 318                                                 rctx->oaep_label,
 319                                                 rctx->oaep_labellen,
 320                                                 rctx->md, rctx->mgf1md);
 321     } else
 322         ret = RSA_private_decrypt(inlen, in, out, ctx->pkey->pkey.rsa,
 323                                   rctx->pad_mode);
 324     if (ret < 0)
 325         return ret;
 326     *outlen = ret;
 327     return 1;
 328 }
 329
 330 static int check_padding_md(const EVP_MD *md, int padding)
 331 {
 332     int mdnid;
 333     if (!md)
 334         return 1;
 335
 336     mdnid = EVP_MD_type(md);
 337
 338     if (padding == RSA_NO_PADDING) {
 339         RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_PADDING_MODE);
 340         return 0;
 341     }
 342
 343     if (padding == RSA_X931_PADDING) {
 344         if (RSA_X931_hash_id(mdnid) == -1) {
 345             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_X931_DIGEST);
 346             return 0;
 347         }
 348     } else {
 349         switch(mdnid) {
 350         /* List of all supported RSA digests */
 351         case NID_sha1:
 352         case NID_sha224:
 353         case NID_sha256:
 354         case NID_sha384:
 355         case NID_sha512:
 356         case NID_md5:
 357         case NID_md5_sha1:
 358         case NID_md2:
 359         case NID_md4:
 360         case NID_mdc2:
 361         case NID_ripemd160:
 362             return 1;
 363
 364         default:
 365             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_DIGEST);
 366             return 0;
 367
 368         }
 369     }
 370
 371     return 1;
 372 }
 373
 374 static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 375 {
 376     RSA_PKEY_CTX *rctx = ctx->data;
 377     switch (type) {
 378     case EVP_PKEY_CTRL_RSA_PADDING:
 379         if ((p1 >= RSA_PKCS1_PADDING) && (p1 <= RSA_PKCS1_PSS_PADDING)) {
 380             if (!check_padding_md(rctx->md, p1))
 381                 return 0;
 382             if (p1 == RSA_PKCS1_PSS_PADDING) {
 383                 if (!(ctx->operation &
 384                       (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)))
 385                     goto bad_pad;
 386                 if (!rctx->md)
 387                     rctx->md = EVP_sha1();
 388             }
 389             if (p1 == RSA_PKCS1_OAEP_PADDING) {
 390                 if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))
 391                     goto bad_pad;
 392                 if (!rctx->md)
 393                     rctx->md = EVP_sha1();
 394             }
 395             rctx->pad_mode = p1;
 396             return 1;
 397         }
 398  bad_pad:
 399         RSAerr(RSA_F_PKEY_RSA_CTRL,
 400                RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
 401         return -2;
 402
 403     case EVP_PKEY_CTRL_GET_RSA_PADDING:
 404         *(int *)p2 = rctx->pad_mode;
 405         return 1;
 406
 407     case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
 408     case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
 409         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
 410             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
 411             return -2;
 412         }
 413         if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN)
 414             *(int *)p2 = rctx->saltlen;
 415         else {
 416             if (p1 < -2)
 417                 return -2;
 418             rctx->saltlen = p1;
 419         }
 420         return 1;
 421
 422     case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
 423         if (p1 < 512) {
 424             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_KEY_SIZE_TOO_SMALL);
 425             return -2;
 426         }
 427         rctx->nbits = p1;
 428         return 1;
 429
 430     case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
 431         if (p2 == NULL || !BN_is_odd((BIGNUM *)p2) || BN_is_one((BIGNUM *)p2)) {
 432             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_BAD_E_VALUE);
 433             return -2;
 434         }
 435         BN_free(rctx->pub_exp);
 436         rctx->pub_exp = p2;
 437         return 1;
 438
 439     case EVP_PKEY_CTRL_RSA_OAEP_MD:
 440     case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
 441         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 442             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 443             return -2;
 444         }
 445         if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD)
 446             *(const EVP_MD **)p2 = rctx->md;
 447         else
 448             rctx->md = p2;
 449         return 1;
 450
 451     case EVP_PKEY_CTRL_MD:
 452         if (!check_padding_md(p2, rctx->pad_mode))
 453             return 0;
 454         rctx->md = p2;
 455         return 1;
 456
 457     case EVP_PKEY_CTRL_GET_MD:
 458         *(const EVP_MD **)p2 = rctx->md;
 459         return 1;
 460
 461     case EVP_PKEY_CTRL_RSA_MGF1_MD:
 462     case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
 463         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING
 464             && rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 465             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD);
 466             return -2;
 467         }
 468         if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) {
 469             if (rctx->mgf1md)
 470                 *(const EVP_MD **)p2 = rctx->mgf1md;
 471             else
 472                 *(const EVP_MD **)p2 = rctx->md;
 473         } else
 474             rctx->mgf1md = p2;
 475         return 1;
 476
 477     case EVP_PKEY_CTRL_RSA_OAEP_LABEL:
 478         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 479             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 480             return -2;
 481         }
 482         OPENSSL_free(rctx->oaep_label);
 483         if (p2 && p1 > 0) {
 484             rctx->oaep_label = p2;
 485             rctx->oaep_labellen = p1;
 486         } else {
 487             rctx->oaep_label = NULL;
 488             rctx->oaep_labellen = 0;
 489         }
 490         return 1;
 491
 492     case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
 493         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 494             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 495             return -2;
 496         }
 497         *(unsigned char **)p2 = rctx->oaep_label;
 498         return rctx->oaep_labellen;
 499
 500     case EVP_PKEY_CTRL_DIGESTINIT:
 501     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 502     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 503     case EVP_PKEY_CTRL_PKCS7_SIGN:
 504         return 1;
 505 #ifndef OPENSSL_NO_CMS
 506     case EVP_PKEY_CTRL_CMS_DECRYPT:
 507     case EVP_PKEY_CTRL_CMS_ENCRYPT:
 508     case EVP_PKEY_CTRL_CMS_SIGN:
 509         return 1;
 510 #endif
 511     case EVP_PKEY_CTRL_PEER_KEY:
 512         RSAerr(RSA_F_PKEY_RSA_CTRL,
 513                RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 514         return -2;
 515
 516     default:
 517         return -2;
 518
 519     }
 520 }
 521
 522 static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 523                              const char *type, const char *value)
 524 {
 525     if (!value) {
 526         RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
 527         return 0;
 528     }
 529     if (strcmp(type, "rsa_padding_mode") == 0) {
 530         int pm;
 531         if (strcmp(value, "pkcs1") == 0)
 532             pm = RSA_PKCS1_PADDING;
 533         else if (strcmp(value, "sslv23") == 0)
 534             pm = RSA_SSLV23_PADDING;
 535         else if (strcmp(value, "none") == 0)
 536             pm = RSA_NO_PADDING;
 537         else if (strcmp(value, "oeap") == 0)
 538             pm = RSA_PKCS1_OAEP_PADDING;
 539         else if (strcmp(value, "oaep") == 0)
 540             pm = RSA_PKCS1_OAEP_PADDING;
 541         else if (strcmp(value, "x931") == 0)
 542             pm = RSA_X931_PADDING;
 543         else if (strcmp(value, "pss") == 0)
 544             pm = RSA_PKCS1_PSS_PADDING;
 545         else {
 546             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_UNKNOWN_PADDING_TYPE);
 547             return -2;
 548         }
 549         return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
 550     }
 551
 552     if (strcmp(type, "rsa_pss_saltlen") == 0) {
 553         int saltlen;
 554         saltlen = atoi(value);
 555         return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
 556     }
 557
 558     if (strcmp(type, "rsa_keygen_bits") == 0) {
 559         int nbits;
 560         nbits = atoi(value);
 561         return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits);
 562     }
 563
 564     if (strcmp(type, "rsa_keygen_pubexp") == 0) {
 565         int ret;
 566         BIGNUM *pubexp = NULL;
 567         if (!BN_asc2bn(&pubexp, value))
 568             return 0;
 569         ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
 570         if (ret <= 0)
 571             BN_free(pubexp);
 572         return ret;
 573     }
 574
 575     if (strcmp(type, "rsa_mgf1_md") == 0) {
 576         const EVP_MD *md;
 577         if ((md = EVP_get_digestbyname(value)) == NULL) {
 578             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_INVALID_DIGEST);
 579             return 0;
 580         }
 581         return EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md);
 582     }
 583
 584     if (strcmp(type, "rsa_oaep_md") == 0) {
 585         const EVP_MD *md;
 586         if ((md = EVP_get_digestbyname(value)) == NULL) {
 587             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_INVALID_DIGEST);
 588             return 0;
 589         }
 590         return EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md);
 591     }
 592     if (strcmp(type, "rsa_oaep_label") == 0) {
 593         unsigned char *lab;
 594         long lablen;
 595         int ret;
 596         lab = OPENSSL_hexstr2buf(value, &lablen);
 597         if (!lab)
 598             return 0;
 599         ret = EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, lab, lablen);
 600         if (ret <= 0)
 601             OPENSSL_free(lab);
 602         return ret;
 603     }
 604
 605     return -2;
 606 }
 607
 608 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 609 {
 610     RSA *rsa = NULL;
 611     RSA_PKEY_CTX *rctx = ctx->data;
 612     BN_GENCB *pcb;
 613     int ret;
 614     if (rctx->pub_exp == NULL) {
 615         rctx->pub_exp = BN_new();
 616         if (rctx->pub_exp == NULL || !BN_set_word(rctx->pub_exp, RSA_F4))
 617             return 0;
 618     }
 619     rsa = RSA_new();
 620     if (rsa == NULL)
 621         return 0;
 622     if (ctx->pkey_gencb) {
 623         pcb = BN_GENCB_new();
 624         if (pcb == NULL) {
 625             RSA_free(rsa);
 626             return 0;
 627         }
 628         evp_pkey_set_cb_translate(pcb, ctx);
 629     } else
 630         pcb = NULL;
 631     ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
 632     BN_GENCB_free(pcb);
 633     if (ret > 0)
 634         EVP_PKEY_assign_RSA(pkey, rsa);
 635     else
 636         RSA_free(rsa);
 637     return ret;
 638 }
 639
 640 const EVP_PKEY_METHOD rsa_pkey_meth = {
 641     EVP_PKEY_RSA,
 642     EVP_PKEY_FLAG_AUTOARGLEN,
 643     pkey_rsa_init,
 644     pkey_rsa_copy,
 645     pkey_rsa_cleanup,
 646
 647     0, 0,
 648
 649     0,
 650     pkey_rsa_keygen,
 651
 652     0,
 653     pkey_rsa_sign,
 654
 655     0,
 656     pkey_rsa_verify,
 657
 658     0,
 659     pkey_rsa_verifyrecover,
 660
 661     0, 0, 0, 0,
 662
 663     0,
 664     pkey_rsa_encrypt,
 665
 666     0,
 667     pkey_rsa_decrypt,
 668
 669     0, 0,
 670
 671     pkey_rsa_ctrl,
 672     pkey_rsa_ctrl_str
 673 };