crypto/rsa/rsa_pmeth.c

   1 /* crypto/rsa/rsa_pmeth.c */
   2 /*
   3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
   4  * 2006.
   5  */
   6 /* ====================================================================
   7  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  *
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in
  18  *    the documentation and/or other materials provided with the
  19  *    distribution.
  20  *
  21  * 3. All advertising materials mentioning features or use of this
  22  *    software must display the following acknowledgment:
  23  *    "This product includes software developed by the OpenSSL Project
  24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  25  *
  26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  27  *    endorse or promote products derived from this software without
  28  *    prior written permission. For written permission, please contact
  29  *    licensing@OpenSSL.org.
  30  *
  31  * 5. Products derived from this software may not be called "OpenSSL"
  32  *    nor may "OpenSSL" appear in their names without prior written
  33  *    permission of the OpenSSL Project.
  34  *
  35  * 6. Redistributions of any form whatsoever must retain the following
  36  *    acknowledgment:
  37  *    "This product includes software developed by the OpenSSL Project
  38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  51  * OF THE POSSIBILITY OF SUCH DAMAGE.
  52  * ====================================================================
  53  *
  54  * This product includes cryptographic software written by Eric Young
  55  * (eay@cryptsoft.com).  This product includes software written by Tim
  56  * Hudson (tjh@cryptsoft.com).
  57  *
  58  */
  59
  60 #include <stdio.h>
  61 #include "cryptlib.h"
  62 #include <openssl/asn1t.h>
  63 #include <openssl/x509.h>
  64 #include <openssl/rsa.h>
  65 #include <openssl/bn.h>
  66 #include <openssl/evp.h>
  67 #include <openssl/x509v3.h>
  68 #ifndef OPENSSL_NO_CMS
  69 # include <openssl/cms.h>
  70 #endif
  71 #include "internal/evp_int.h"
  72 #include "rsa_locl.h"
  73
  74 /* RSA pkey context structure */
  75
  76 typedef struct {
  77     /* Key gen parameters */
  78     int nbits;
  79     BIGNUM *pub_exp;
  80     /* Keygen callback info */
  81     int gentmp[2];
  82     /* RSA padding mode */
  83     int pad_mode;
  84     /* message digest */
  85     const EVP_MD *md;
  86     /* message digest for MGF1 */
  87     const EVP_MD *mgf1md;
  88     /* PSS salt length */
  89     int saltlen;
  90     /* Temp buffer */
  91     unsigned char *tbuf;
  92     /* OAEP label */
  93     unsigned char *oaep_label;
  94     size_t oaep_labellen;
  95 } RSA_PKEY_CTX;
  96
  97 static int pkey_rsa_init(EVP_PKEY_CTX *ctx)
  98 {
  99     RSA_PKEY_CTX *rctx;
 100     rctx = OPENSSL_malloc(sizeof(*rctx));
 101     if (!rctx)
 102         return 0;
 103     rctx->nbits = 1024;
 104     rctx->pub_exp = NULL;
 105     rctx->pad_mode = RSA_PKCS1_PADDING;
 106     rctx->md = NULL;
 107     rctx->mgf1md = NULL;
 108     rctx->tbuf = NULL;
 109
 110     rctx->saltlen = -2;
 111
 112     rctx->oaep_label = NULL;
 113     rctx->oaep_labellen = 0;
 114
 115     ctx->data = rctx;
 116     ctx->keygen_info = rctx->gentmp;
 117     ctx->keygen_info_count = 2;
 118
 119     return 1;
 120 }
 121
 122 static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
 123 {
 124     RSA_PKEY_CTX *dctx, *sctx;
 125     if (!pkey_rsa_init(dst))
 126         return 0;
 127     sctx = src->data;
 128     dctx = dst->data;
 129     dctx->nbits = sctx->nbits;
 130     if (sctx->pub_exp) {
 131         dctx->pub_exp = BN_dup(sctx->pub_exp);
 132         if (!dctx->pub_exp)
 133             return 0;
 134     }
 135     dctx->pad_mode = sctx->pad_mode;
 136     dctx->md = sctx->md;
 137     dctx->mgf1md = sctx->mgf1md;
 138     if (sctx->oaep_label) {
 139         OPENSSL_free(dctx->oaep_label);
 140         dctx->oaep_label = BUF_memdup(sctx->oaep_label, sctx->oaep_labellen);
 141         if (!dctx->oaep_label)
 142             return 0;
 143         dctx->oaep_labellen = sctx->oaep_labellen;
 144     }
 145     return 1;
 146 }
 147
 148 static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk)
 149 {
 150     if (ctx->tbuf)
 151         return 1;
 152     ctx->tbuf = OPENSSL_malloc(EVP_PKEY_size(pk->pkey));
 153     if (!ctx->tbuf)
 154         return 0;
 155     return 1;
 156 }
 157
 158 static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx)
 159 {
 160     RSA_PKEY_CTX *rctx = ctx->data;
 161     if (rctx) {
 162         BN_free(rctx->pub_exp);
 163         OPENSSL_free(rctx->tbuf);
 164         OPENSSL_free(rctx->oaep_label);
 165         OPENSSL_free(rctx);
 166     }
 167 }
 168
 169 static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig,
 170                          size_t *siglen, const unsigned char *tbs,
 171                          size_t tbslen)
 172 {
 173     int ret;
 174     RSA_PKEY_CTX *rctx = ctx->data;
 175     RSA *rsa = ctx->pkey->pkey.rsa;
 176
 177     if (rctx->md) {
 178         if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
 179             RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_INVALID_DIGEST_LENGTH);
 180             return -1;
 181         }
 182
 183         if (EVP_MD_type(rctx->md) == NID_mdc2) {
 184             unsigned int sltmp;
 185             if (rctx->pad_mode != RSA_PKCS1_PADDING)
 186                 return -1;
 187             ret = RSA_sign_ASN1_OCTET_STRING(NID_mdc2,
 188                                              tbs, tbslen, sig, &sltmp, rsa);
 189
 190             if (ret <= 0)
 191                 return ret;
 192             ret = sltmp;
 193         } else if (rctx->pad_mode == RSA_X931_PADDING) {
 194             if ((size_t)EVP_PKEY_size(ctx->pkey) < tbslen + 1) {
 195                 RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_KEY_SIZE_TOO_SMALL);
 196                 return -1;
 197             }
 198             if (!setup_tbuf(rctx, ctx)) {
 199                 RSAerr(RSA_F_PKEY_RSA_SIGN, ERR_R_MALLOC_FAILURE);
 200                 return -1;
 201             }
 202             memcpy(rctx->tbuf, tbs, tbslen);
 203             rctx->tbuf[tbslen] = RSA_X931_hash_id(EVP_MD_type(rctx->md));
 204             ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf,
 205                                       sig, rsa, RSA_X931_PADDING);
 206         } else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
 207             unsigned int sltmp;
 208             ret = RSA_sign(EVP_MD_type(rctx->md),
 209                            tbs, tbslen, sig, &sltmp, rsa);
 210             if (ret <= 0)
 211                 return ret;
 212             ret = sltmp;
 213         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 214             if (!setup_tbuf(rctx, ctx))
 215                 return -1;
 216             if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa,
 217                                                 rctx->tbuf, tbs,
 218                                                 rctx->md, rctx->mgf1md,
 219                                                 rctx->saltlen))
 220                 return -1;
 221             ret = RSA_private_encrypt(RSA_size(rsa), rctx->tbuf,
 222                                       sig, rsa, RSA_NO_PADDING);
 223         } else
 224             return -1;
 225     } else
 226         ret = RSA_private_encrypt(tbslen, tbs, sig, ctx->pkey->pkey.rsa,
 227                                   rctx->pad_mode);
 228     if (ret < 0)
 229         return ret;
 230     *siglen = ret;
 231     return 1;
 232 }
 233
 234 static int pkey_rsa_verifyrecover(EVP_PKEY_CTX *ctx,
 235                                   unsigned char *rout, size_t *routlen,
 236                                   const unsigned char *sig, size_t siglen)
 237 {
 238     int ret;
 239     RSA_PKEY_CTX *rctx = ctx->data;
 240
 241     if (rctx->md) {
 242         if (rctx->pad_mode == RSA_X931_PADDING) {
 243             if (!setup_tbuf(rctx, ctx))
 244                 return -1;
 245             ret = RSA_public_decrypt(siglen, sig,
 246                                      rctx->tbuf, ctx->pkey->pkey.rsa,
 247                                      RSA_X931_PADDING);
 248             if (ret < 1)
 249                 return 0;
 250             ret--;
 251             if (rctx->tbuf[ret] != RSA_X931_hash_id(EVP_MD_type(rctx->md))) {
 252                 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
 253                        RSA_R_ALGORITHM_MISMATCH);
 254                 return 0;
 255             }
 256             if (ret != EVP_MD_size(rctx->md)) {
 257                 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
 258                        RSA_R_INVALID_DIGEST_LENGTH);
 259                 return 0;
 260             }
 261             if (rout)
 262                 memcpy(rout, rctx->tbuf, ret);
 263         } else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
 264             size_t sltmp;
 265             ret = int_rsa_verify(EVP_MD_type(rctx->md),
 266                                  NULL, 0, rout, &sltmp,
 267                                  sig, siglen, ctx->pkey->pkey.rsa);
 268             if (ret <= 0)
 269                 return 0;
 270             ret = sltmp;
 271         } else
 272             return -1;
 273     } else
 274         ret = RSA_public_decrypt(siglen, sig, rout, ctx->pkey->pkey.rsa,
 275                                  rctx->pad_mode);
 276     if (ret < 0)
 277         return ret;
 278     *routlen = ret;
 279     return 1;
 280 }
 281
 282 static int pkey_rsa_verify(EVP_PKEY_CTX *ctx,
 283                            const unsigned char *sig, size_t siglen,
 284                            const unsigned char *tbs, size_t tbslen)
 285 {
 286     RSA_PKEY_CTX *rctx = ctx->data;
 287     RSA *rsa = ctx->pkey->pkey.rsa;
 288     size_t rslen;
 289     if (rctx->md) {
 290         if (rctx->pad_mode == RSA_PKCS1_PADDING)
 291             return RSA_verify(EVP_MD_type(rctx->md), tbs, tbslen,
 292                               sig, siglen, rsa);
 293         if (rctx->pad_mode == RSA_X931_PADDING) {
 294             if (pkey_rsa_verifyrecover(ctx, NULL, &rslen, sig, siglen) <= 0)
 295                 return 0;
 296         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 297             int ret;
 298             if (!setup_tbuf(rctx, ctx))
 299                 return -1;
 300             ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
 301                                      rsa, RSA_NO_PADDING);
 302             if (ret <= 0)
 303                 return 0;
 304             ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs,
 305                                             rctx->md, rctx->mgf1md,
 306                                             rctx->tbuf, rctx->saltlen);
 307             if (ret <= 0)
 308                 return 0;
 309             return 1;
 310         } else
 311             return -1;
 312     } else {
 313         if (!setup_tbuf(rctx, ctx))
 314             return -1;
 315         rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf,
 316                                    rsa, rctx->pad_mode);
 317         if (rslen == 0)
 318             return 0;
 319     }
 320
 321     if ((rslen != tbslen) || memcmp(tbs, rctx->tbuf, rslen))
 322         return 0;
 323
 324     return 1;
 325
 326 }
 327
 328 static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx,
 329                             unsigned char *out, size_t *outlen,
 330                             const unsigned char *in, size_t inlen)
 331 {
 332     int ret;
 333     RSA_PKEY_CTX *rctx = ctx->data;
 334     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
 335         int klen = RSA_size(ctx->pkey->pkey.rsa);
 336         if (!setup_tbuf(rctx, ctx))
 337             return -1;
 338         if (!RSA_padding_add_PKCS1_OAEP_mgf1(rctx->tbuf, klen,
 339                                              in, inlen,
 340                                              rctx->oaep_label,
 341                                              rctx->oaep_labellen,
 342                                              rctx->md, rctx->mgf1md))
 343             return -1;
 344         ret = RSA_public_encrypt(klen, rctx->tbuf, out,
 345                                  ctx->pkey->pkey.rsa, RSA_NO_PADDING);
 346     } else
 347         ret = RSA_public_encrypt(inlen, in, out, ctx->pkey->pkey.rsa,
 348                                  rctx->pad_mode);
 349     if (ret < 0)
 350         return ret;
 351     *outlen = ret;
 352     return 1;
 353 }
 354
 355 static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx,
 356                             unsigned char *out, size_t *outlen,
 357                             const unsigned char *in, size_t inlen)
 358 {
 359     int ret;
 360     RSA_PKEY_CTX *rctx = ctx->data;
 361     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
 362         int i;
 363         if (!setup_tbuf(rctx, ctx))
 364             return -1;
 365         ret = RSA_private_decrypt(inlen, in, rctx->tbuf,
 366                                   ctx->pkey->pkey.rsa, RSA_NO_PADDING);
 367         if (ret <= 0)
 368             return ret;
 369         for (i = 0; i < ret; i++) {
 370             if (rctx->tbuf[i])
 371                 break;
 372         }
 373         ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, ret, rctx->tbuf + i,
 374                                                 ret - i, ret,
 375                                                 rctx->oaep_label,
 376                                                 rctx->oaep_labellen,
 377                                                 rctx->md, rctx->mgf1md);
 378     } else
 379         ret = RSA_private_decrypt(inlen, in, out, ctx->pkey->pkey.rsa,
 380                                   rctx->pad_mode);
 381     if (ret < 0)
 382         return ret;
 383     *outlen = ret;
 384     return 1;
 385 }
 386
 387 static int check_padding_md(const EVP_MD *md, int padding)
 388 {
 389     if (!md)
 390         return 1;
 391
 392     if (padding == RSA_NO_PADDING) {
 393         RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_PADDING_MODE);
 394         return 0;
 395     }
 396
 397     if (padding == RSA_X931_PADDING) {
 398         if (RSA_X931_hash_id(EVP_MD_type(md)) == -1) {
 399             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_X931_DIGEST);
 400             return 0;
 401         }
 402         return 1;
 403     }
 404
 405     return 1;
 406 }
 407
 408 static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 409 {
 410     RSA_PKEY_CTX *rctx = ctx->data;
 411     switch (type) {
 412     case EVP_PKEY_CTRL_RSA_PADDING:
 413         if ((p1 >= RSA_PKCS1_PADDING) && (p1 <= RSA_PKCS1_PSS_PADDING)) {
 414             if (!check_padding_md(rctx->md, p1))
 415                 return 0;
 416             if (p1 == RSA_PKCS1_PSS_PADDING) {
 417                 if (!(ctx->operation &
 418                       (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)))
 419                     goto bad_pad;
 420                 if (!rctx->md)
 421                     rctx->md = EVP_sha1();
 422             }
 423             if (p1 == RSA_PKCS1_OAEP_PADDING) {
 424                 if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))
 425                     goto bad_pad;
 426                 if (!rctx->md)
 427                     rctx->md = EVP_sha1();
 428             }
 429             rctx->pad_mode = p1;
 430             return 1;
 431         }
 432  bad_pad:
 433         RSAerr(RSA_F_PKEY_RSA_CTRL,
 434                RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
 435         return -2;
 436
 437     case EVP_PKEY_CTRL_GET_RSA_PADDING:
 438         *(int *)p2 = rctx->pad_mode;
 439         return 1;
 440
 441     case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
 442     case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
 443         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
 444             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
 445             return -2;
 446         }
 447         if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN)
 448             *(int *)p2 = rctx->saltlen;
 449         else {
 450             if (p1 < -2)
 451                 return -2;
 452             rctx->saltlen = p1;
 453         }
 454         return 1;
 455
 456     case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
 457         if (p1 < 512) {
 458             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_KEY_SIZE_TOO_SMALL);
 459             return -2;
 460         }
 461         rctx->nbits = p1;
 462         return 1;
 463
 464     case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
 465         if (!p2)
 466             return -2;
 467         BN_free(rctx->pub_exp);
 468         rctx->pub_exp = p2;
 469         return 1;
 470
 471     case EVP_PKEY_CTRL_RSA_OAEP_MD:
 472     case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
 473         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 474             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 475             return -2;
 476         }
 477         if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD)
 478             *(const EVP_MD **)p2 = rctx->md;
 479         else
 480             rctx->md = p2;
 481         return 1;
 482
 483     case EVP_PKEY_CTRL_MD:
 484         if (!check_padding_md(p2, rctx->pad_mode))
 485             return 0;
 486         rctx->md = p2;
 487         return 1;
 488
 489     case EVP_PKEY_CTRL_GET_MD:
 490         *(const EVP_MD **)p2 = rctx->md;
 491         return 1;
 492
 493     case EVP_PKEY_CTRL_RSA_MGF1_MD:
 494     case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
 495         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING
 496             && rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 497             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD);
 498             return -2;
 499         }
 500         if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) {
 501             if (rctx->mgf1md)
 502                 *(const EVP_MD **)p2 = rctx->mgf1md;
 503             else
 504                 *(const EVP_MD **)p2 = rctx->md;
 505         } else
 506             rctx->mgf1md = p2;
 507         return 1;
 508
 509     case EVP_PKEY_CTRL_RSA_OAEP_LABEL:
 510         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 511             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 512             return -2;
 513         }
 514         OPENSSL_free(rctx->oaep_label);
 515         if (p2 && p1 > 0) {
 516             rctx->oaep_label = p2;
 517             rctx->oaep_labellen = p1;
 518         } else {
 519             rctx->oaep_label = NULL;
 520             rctx->oaep_labellen = 0;
 521         }
 522         return 1;
 523
 524     case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
 525         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 526             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 527             return -2;
 528         }
 529         *(unsigned char **)p2 = rctx->oaep_label;
 530         return rctx->oaep_labellen;
 531
 532     case EVP_PKEY_CTRL_DIGESTINIT:
 533     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 534     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 535     case EVP_PKEY_CTRL_PKCS7_SIGN:
 536         return 1;
 537 #ifndef OPENSSL_NO_CMS
 538     case EVP_PKEY_CTRL_CMS_DECRYPT:
 539     case EVP_PKEY_CTRL_CMS_ENCRYPT:
 540     case EVP_PKEY_CTRL_CMS_SIGN:
 541         return 1;
 542 #endif
 543     case EVP_PKEY_CTRL_PEER_KEY:
 544         RSAerr(RSA_F_PKEY_RSA_CTRL,
 545                RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 546         return -2;
 547
 548     default:
 549         return -2;
 550
 551     }
 552 }
 553
 554 static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 555                              const char *type, const char *value)
 556 {
 557     if (!value) {
 558         RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
 559         return 0;
 560     }
 561     if (!strcmp(type, "rsa_padding_mode")) {
 562         int pm;
 563         if (!strcmp(value, "pkcs1"))
 564             pm = RSA_PKCS1_PADDING;
 565         else if (!strcmp(value, "sslv23"))
 566             pm = RSA_SSLV23_PADDING;
 567         else if (!strcmp(value, "none"))
 568             pm = RSA_NO_PADDING;
 569         else if (!strcmp(value, "oeap"))
 570             pm = RSA_PKCS1_OAEP_PADDING;
 571         else if (!strcmp(value, "oaep"))
 572             pm = RSA_PKCS1_OAEP_PADDING;
 573         else if (!strcmp(value, "x931"))
 574             pm = RSA_X931_PADDING;
 575         else if (!strcmp(value, "pss"))
 576             pm = RSA_PKCS1_PSS_PADDING;
 577         else {
 578             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_UNKNOWN_PADDING_TYPE);
 579             return -2;
 580         }
 581         return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
 582     }
 583
 584     if (!strcmp(type, "rsa_pss_saltlen")) {
 585         int saltlen;
 586         saltlen = atoi(value);
 587         return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
 588     }
 589
 590     if (!strcmp(type, "rsa_keygen_bits")) {
 591         int nbits;
 592         nbits = atoi(value);
 593         return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits);
 594     }
 595
 596     if (!strcmp(type, "rsa_keygen_pubexp")) {
 597         int ret;
 598         BIGNUM *pubexp = NULL;
 599         if (!BN_asc2bn(&pubexp, value))
 600             return 0;
 601         ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
 602         if (ret <= 0)
 603             BN_free(pubexp);
 604         return ret;
 605     }
 606
 607     if (!strcmp(type, "rsa_mgf1_md")) {
 608         const EVP_MD *md;
 609         if (!(md = EVP_get_digestbyname(value))) {
 610             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_INVALID_DIGEST);
 611             return 0;
 612         }
 613         return EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md);
 614     }
 615
 616     if (!strcmp(type, "rsa_oaep_md")) {
 617         const EVP_MD *md;
 618         if (!(md = EVP_get_digestbyname(value))) {
 619             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_INVALID_DIGEST);
 620             return 0;
 621         }
 622         return EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md);
 623     }
 624     if (!strcmp(type, "rsa_oaep_label")) {
 625         unsigned char *lab;
 626         long lablen;
 627         int ret;
 628         lab = string_to_hex(value, &lablen);
 629         if (!lab)
 630             return 0;
 631         ret = EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, lab, lablen);
 632         if (ret <= 0)
 633             OPENSSL_free(lab);
 634         return ret;
 635     }
 636
 637     return -2;
 638 }
 639
 640 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 641 {
 642     RSA *rsa = NULL;
 643     RSA_PKEY_CTX *rctx = ctx->data;
 644     BN_GENCB *pcb;
 645     int ret;
 646     if (!rctx->pub_exp) {
 647         rctx->pub_exp = BN_new();
 648         if (!rctx->pub_exp || !BN_set_word(rctx->pub_exp, RSA_F4))
 649             return 0;
 650     }
 651     rsa = RSA_new();
 652     if (!rsa)
 653         return 0;
 654     if (ctx->pkey_gencb) {
 655         pcb = BN_GENCB_new();
 656         if (!pcb) {
 657             RSA_free(rsa);
 658             return 0;
 659         }
 660         evp_pkey_set_cb_translate(pcb, ctx);
 661     } else
 662         pcb = NULL;
 663     ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
 664     BN_GENCB_free(pcb);
 665     if (ret > 0)
 666         EVP_PKEY_assign_RSA(pkey, rsa);
 667     else
 668         RSA_free(rsa);
 669     return ret;
 670 }
 671
 672 const EVP_PKEY_METHOD rsa_pkey_meth = {
 673     EVP_PKEY_RSA,
 674     EVP_PKEY_FLAG_AUTOARGLEN,
 675     pkey_rsa_init,
 676     pkey_rsa_copy,
 677     pkey_rsa_cleanup,
 678
 679     0, 0,
 680
 681     0,
 682     pkey_rsa_keygen,
 683
 684     0,
 685     pkey_rsa_sign,
 686
 687     0,
 688     pkey_rsa_verify,
 689
 690     0,
 691     pkey_rsa_verifyrecover,
 692
 693     0, 0, 0, 0,
 694
 695     0,
 696     pkey_rsa_encrypt,
 697
 698     0,
 699     pkey_rsa_decrypt,
 700
 701     0, 0,
 702
 703     pkey_rsa_ctrl,
 704     pkey_rsa_ctrl_str
 705 };