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     /* Minimum salt length or -1 if no PSS parameter restriction */
  39     int min_saltlen;
  40     /* Temp buffer */
  41     unsigned char *tbuf;
  42     /* OAEP label */
  43     unsigned char *oaep_label;
  44     size_t oaep_labellen;
  45 } RSA_PKEY_CTX;
  46
  47 /* True if PSS parameters are restricted */
  48 #define rsa_pss_restricted(rctx) (rctx->min_saltlen != -1)
  49
  50 static int pkey_rsa_init(EVP_PKEY_CTX *ctx)
  51 {
  52     RSA_PKEY_CTX *rctx = OPENSSL_zalloc(sizeof(*rctx));
  53
  54     if (rctx == NULL)
  55         return 0;
  56     rctx->nbits = 1024;
  57     if (pkey_ctx_is_pss(ctx))
  58         rctx->pad_mode = RSA_PKCS1_PSS_PADDING;
  59     else
  60         rctx->pad_mode = RSA_PKCS1_PADDING;
  61     /* Maximum for sign, auto for verify */
  62     rctx->saltlen = RSA_PSS_SALTLEN_AUTO;
  63     rctx->min_saltlen = -1;
  64     ctx->data = rctx;
  65     ctx->keygen_info = rctx->gentmp;
  66     ctx->keygen_info_count = 2;
  67
  68     return 1;
  69 }
  70
  71 static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
  72 {
  73     RSA_PKEY_CTX *dctx, *sctx;
  74
  75     if (!pkey_rsa_init(dst))
  76         return 0;
  77     sctx = src->data;
  78     dctx = dst->data;
  79     dctx->nbits = sctx->nbits;
  80     if (sctx->pub_exp) {
  81         dctx->pub_exp = BN_dup(sctx->pub_exp);
  82         if (!dctx->pub_exp)
  83             return 0;
  84     }
  85     dctx->pad_mode = sctx->pad_mode;
  86     dctx->md = sctx->md;
  87     dctx->mgf1md = sctx->mgf1md;
  88     if (sctx->oaep_label) {
  89         OPENSSL_free(dctx->oaep_label);
  90         dctx->oaep_label = OPENSSL_memdup(sctx->oaep_label, sctx->oaep_labellen);
  91         if (!dctx->oaep_label)
  92             return 0;
  93         dctx->oaep_labellen = sctx->oaep_labellen;
  94     }
  95     return 1;
  96 }
  97
  98 static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk)
  99 {
 100     if (ctx->tbuf != NULL)
 101         return 1;
 102     ctx->tbuf = OPENSSL_malloc(EVP_PKEY_size(pk->pkey));
 103     if (ctx->tbuf == NULL)
 104         return 0;
 105     return 1;
 106 }
 107
 108 static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx)
 109 {
 110     RSA_PKEY_CTX *rctx = ctx->data;
 111     if (rctx) {
 112         BN_free(rctx->pub_exp);
 113         OPENSSL_free(rctx->tbuf);
 114         OPENSSL_free(rctx->oaep_label);
 115         OPENSSL_free(rctx);
 116     }
 117 }
 118
 119 static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig,
 120                          size_t *siglen, const unsigned char *tbs,
 121                          size_t tbslen)
 122 {
 123     int ret;
 124     RSA_PKEY_CTX *rctx = ctx->data;
 125     RSA *rsa = ctx->pkey->pkey.rsa;
 126
 127     if (rctx->md) {
 128         if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
 129             RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_INVALID_DIGEST_LENGTH);
 130             return -1;
 131         }
 132
 133         if (EVP_MD_type(rctx->md) == NID_mdc2) {
 134             unsigned int sltmp;
 135             if (rctx->pad_mode != RSA_PKCS1_PADDING)
 136                 return -1;
 137             ret = RSA_sign_ASN1_OCTET_STRING(0,
 138                                              tbs, tbslen, sig, &sltmp, rsa);
 139
 140             if (ret <= 0)
 141                 return ret;
 142             ret = sltmp;
 143         } else if (rctx->pad_mode == RSA_X931_PADDING) {
 144             if ((size_t)EVP_PKEY_size(ctx->pkey) < tbslen + 1) {
 145                 RSAerr(RSA_F_PKEY_RSA_SIGN, RSA_R_KEY_SIZE_TOO_SMALL);
 146                 return -1;
 147             }
 148             if (!setup_tbuf(rctx, ctx)) {
 149                 RSAerr(RSA_F_PKEY_RSA_SIGN, ERR_R_MALLOC_FAILURE);
 150                 return -1;
 151             }
 152             memcpy(rctx->tbuf, tbs, tbslen);
 153             rctx->tbuf[tbslen] = RSA_X931_hash_id(EVP_MD_type(rctx->md));
 154             ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf,
 155                                       sig, rsa, RSA_X931_PADDING);
 156         } else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
 157             unsigned int sltmp;
 158             ret = RSA_sign(EVP_MD_type(rctx->md),
 159                            tbs, tbslen, sig, &sltmp, rsa);
 160             if (ret <= 0)
 161                 return ret;
 162             ret = sltmp;
 163         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 164             if (!setup_tbuf(rctx, ctx))
 165                 return -1;
 166             if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa,
 167                                                 rctx->tbuf, tbs,
 168                                                 rctx->md, rctx->mgf1md,
 169                                                 rctx->saltlen))
 170                 return -1;
 171             ret = RSA_private_encrypt(RSA_size(rsa), rctx->tbuf,
 172                                       sig, rsa, RSA_NO_PADDING);
 173         } else
 174             return -1;
 175     } else
 176         ret = RSA_private_encrypt(tbslen, tbs, sig, ctx->pkey->pkey.rsa,
 177                                   rctx->pad_mode);
 178     if (ret < 0)
 179         return ret;
 180     *siglen = ret;
 181     return 1;
 182 }
 183
 184 static int pkey_rsa_verifyrecover(EVP_PKEY_CTX *ctx,
 185                                   unsigned char *rout, size_t *routlen,
 186                                   const unsigned char *sig, size_t siglen)
 187 {
 188     int ret;
 189     RSA_PKEY_CTX *rctx = ctx->data;
 190
 191     if (rctx->md) {
 192         if (rctx->pad_mode == RSA_X931_PADDING) {
 193             if (!setup_tbuf(rctx, ctx))
 194                 return -1;
 195             ret = RSA_public_decrypt(siglen, sig,
 196                                      rctx->tbuf, ctx->pkey->pkey.rsa,
 197                                      RSA_X931_PADDING);
 198             if (ret < 1)
 199                 return 0;
 200             ret--;
 201             if (rctx->tbuf[ret] != RSA_X931_hash_id(EVP_MD_type(rctx->md))) {
 202                 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
 203                        RSA_R_ALGORITHM_MISMATCH);
 204                 return 0;
 205             }
 206             if (ret != EVP_MD_size(rctx->md)) {
 207                 RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
 208                        RSA_R_INVALID_DIGEST_LENGTH);
 209                 return 0;
 210             }
 211             if (rout)
 212                 memcpy(rout, rctx->tbuf, ret);
 213         } else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
 214             size_t sltmp;
 215             ret = int_rsa_verify(EVP_MD_type(rctx->md),
 216                                  NULL, 0, rout, &sltmp,
 217                                  sig, siglen, ctx->pkey->pkey.rsa);
 218             if (ret <= 0)
 219                 return 0;
 220             ret = sltmp;
 221         } else
 222             return -1;
 223     } else
 224         ret = RSA_public_decrypt(siglen, sig, rout, ctx->pkey->pkey.rsa,
 225                                  rctx->pad_mode);
 226     if (ret < 0)
 227         return ret;
 228     *routlen = ret;
 229     return 1;
 230 }
 231
 232 static int pkey_rsa_verify(EVP_PKEY_CTX *ctx,
 233                            const unsigned char *sig, size_t siglen,
 234                            const unsigned char *tbs, size_t tbslen)
 235 {
 236     RSA_PKEY_CTX *rctx = ctx->data;
 237     RSA *rsa = ctx->pkey->pkey.rsa;
 238     size_t rslen;
 239
 240     if (rctx->md) {
 241         if (rctx->pad_mode == RSA_PKCS1_PADDING)
 242             return RSA_verify(EVP_MD_type(rctx->md), tbs, tbslen,
 243                               sig, siglen, rsa);
 244         if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
 245             RSAerr(RSA_F_PKEY_RSA_VERIFY, RSA_R_INVALID_DIGEST_LENGTH);
 246             return -1;
 247         }
 248         if (rctx->pad_mode == RSA_X931_PADDING) {
 249             if (pkey_rsa_verifyrecover(ctx, NULL, &rslen, sig, siglen) <= 0)
 250                 return 0;
 251         } else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
 252             int ret;
 253             if (!setup_tbuf(rctx, ctx))
 254                 return -1;
 255             ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
 256                                      rsa, RSA_NO_PADDING);
 257             if (ret <= 0)
 258                 return 0;
 259             ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs,
 260                                             rctx->md, rctx->mgf1md,
 261                                             rctx->tbuf, rctx->saltlen);
 262             if (ret <= 0)
 263                 return 0;
 264             return 1;
 265         } else
 266             return -1;
 267     } else {
 268         if (!setup_tbuf(rctx, ctx))
 269             return -1;
 270         rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf,
 271                                    rsa, rctx->pad_mode);
 272         if (rslen == 0)
 273             return 0;
 274     }
 275
 276     if ((rslen != tbslen) || memcmp(tbs, rctx->tbuf, rslen))
 277         return 0;
 278
 279     return 1;
 280
 281 }
 282
 283 static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx,
 284                             unsigned char *out, size_t *outlen,
 285                             const unsigned char *in, size_t inlen)
 286 {
 287     int ret;
 288     RSA_PKEY_CTX *rctx = ctx->data;
 289
 290     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
 291         int klen = RSA_size(ctx->pkey->pkey.rsa);
 292         if (!setup_tbuf(rctx, ctx))
 293             return -1;
 294         if (!RSA_padding_add_PKCS1_OAEP_mgf1(rctx->tbuf, klen,
 295                                              in, inlen,
 296                                              rctx->oaep_label,
 297                                              rctx->oaep_labellen,
 298                                              rctx->md, rctx->mgf1md))
 299             return -1;
 300         ret = RSA_public_encrypt(klen, rctx->tbuf, out,
 301                                  ctx->pkey->pkey.rsa, RSA_NO_PADDING);
 302     } else
 303         ret = RSA_public_encrypt(inlen, in, out, ctx->pkey->pkey.rsa,
 304                                  rctx->pad_mode);
 305     if (ret < 0)
 306         return ret;
 307     *outlen = ret;
 308     return 1;
 309 }
 310
 311 static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx,
 312                             unsigned char *out, size_t *outlen,
 313                             const unsigned char *in, size_t inlen)
 314 {
 315     int ret;
 316     RSA_PKEY_CTX *rctx = ctx->data;
 317
 318     if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING) {
 319         if (!setup_tbuf(rctx, ctx))
 320             return -1;
 321         ret = RSA_private_decrypt(inlen, in, rctx->tbuf,
 322                                   ctx->pkey->pkey.rsa, RSA_NO_PADDING);
 323         if (ret <= 0)
 324             return ret;
 325         ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, ret, rctx->tbuf,
 326                                                 ret, ret,
 327                                                 rctx->oaep_label,
 328                                                 rctx->oaep_labellen,
 329                                                 rctx->md, rctx->mgf1md);
 330     } else
 331         ret = RSA_private_decrypt(inlen, in, out, ctx->pkey->pkey.rsa,
 332                                   rctx->pad_mode);
 333     if (ret < 0)
 334         return ret;
 335     *outlen = ret;
 336     return 1;
 337 }
 338
 339 static int check_padding_md(const EVP_MD *md, int padding)
 340 {
 341     int mdnid;
 342
 343     if (!md)
 344         return 1;
 345
 346     mdnid = EVP_MD_type(md);
 347
 348     if (padding == RSA_NO_PADDING) {
 349         RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_PADDING_MODE);
 350         return 0;
 351     }
 352
 353     if (padding == RSA_X931_PADDING) {
 354         if (RSA_X931_hash_id(mdnid) == -1) {
 355             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_X931_DIGEST);
 356             return 0;
 357         }
 358     } else {
 359         switch(mdnid) {
 360         /* List of all supported RSA digests */
 361         case NID_sha1:
 362         case NID_sha224:
 363         case NID_sha256:
 364         case NID_sha384:
 365         case NID_sha512:
 366         case NID_md5:
 367         case NID_md5_sha1:
 368         case NID_md2:
 369         case NID_md4:
 370         case NID_mdc2:
 371         case NID_ripemd160:
 372             return 1;
 373
 374         default:
 375             RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_DIGEST);
 376             return 0;
 377
 378         }
 379     }
 380
 381     return 1;
 382 }
 383
 384 static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 385 {
 386     RSA_PKEY_CTX *rctx = ctx->data;
 387
 388     switch (type) {
 389     case EVP_PKEY_CTRL_RSA_PADDING:
 390         if ((p1 >= RSA_PKCS1_PADDING) && (p1 <= RSA_PKCS1_PSS_PADDING)) {
 391             if (!check_padding_md(rctx->md, p1))
 392                 return 0;
 393             if (p1 == RSA_PKCS1_PSS_PADDING) {
 394                 if (!(ctx->operation &
 395                       (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)))
 396                     goto bad_pad;
 397                 if (!rctx->md)
 398                     rctx->md = EVP_sha1();
 399             } else if (pkey_ctx_is_pss(ctx)) {
 400                 goto bad_pad;
 401             }
 402             if (p1 == RSA_PKCS1_OAEP_PADDING) {
 403                 if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))
 404                     goto bad_pad;
 405                 if (!rctx->md)
 406                     rctx->md = EVP_sha1();
 407             }
 408             rctx->pad_mode = p1;
 409             return 1;
 410         }
 411  bad_pad:
 412         RSAerr(RSA_F_PKEY_RSA_CTRL,
 413                RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
 414         return -2;
 415
 416     case EVP_PKEY_CTRL_GET_RSA_PADDING:
 417         *(int *)p2 = rctx->pad_mode;
 418         return 1;
 419
 420     case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
 421     case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
 422         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING) {
 423             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
 424             return -2;
 425         }
 426         if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN) {
 427             *(int *)p2 = rctx->saltlen;
 428         } else {
 429             if (p1 < RSA_PSS_SALTLEN_MAX)
 430                 return -2;
 431             if (rsa_pss_restricted(rctx)) {
 432                 if (p1 == RSA_PSS_SALTLEN_AUTO
 433                     && ctx->operation == EVP_PKEY_OP_VERIFY) {
 434                     RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
 435                     return -2;
 436                 }
 437                 if ((p1 == RSA_PSS_SALTLEN_DIGEST
 438                      && rctx->min_saltlen > EVP_MD_size(rctx->md))
 439                     || (p1 >= 0 && p1 < rctx->min_saltlen)) {
 440                     RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_PSS_SALTLEN_TOO_SMALL);
 441                     return 0;
 442                 }
 443             }
 444             rctx->saltlen = p1;
 445         }
 446         return 1;
 447
 448     case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
 449         if (p1 < 512) {
 450             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_KEY_SIZE_TOO_SMALL);
 451             return -2;
 452         }
 453         rctx->nbits = p1;
 454         return 1;
 455
 456     case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
 457         if (p2 == NULL || !BN_is_odd((BIGNUM *)p2) || BN_is_one((BIGNUM *)p2)) {
 458             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_BAD_E_VALUE);
 459             return -2;
 460         }
 461         BN_free(rctx->pub_exp);
 462         rctx->pub_exp = p2;
 463         return 1;
 464
 465     case EVP_PKEY_CTRL_RSA_OAEP_MD:
 466     case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
 467         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 468             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 469             return -2;
 470         }
 471         if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD)
 472             *(const EVP_MD **)p2 = rctx->md;
 473         else
 474             rctx->md = p2;
 475         return 1;
 476
 477     case EVP_PKEY_CTRL_MD:
 478         if (!check_padding_md(p2, rctx->pad_mode))
 479             return 0;
 480         if (rsa_pss_restricted(rctx)) {
 481             if (EVP_MD_type(rctx->md) == EVP_MD_type(p2))
 482                 return 1;
 483             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_DIGEST_NOT_ALLOWED);
 484             return 0;
 485         }
 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             if (rsa_pss_restricted(rctx)) {
 507                 if (EVP_MD_type(rctx->mgf1md) == EVP_MD_type(p2))
 508                     return 1;
 509                 RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_MGF1_DIGEST_NOT_ALLOWED);
 510                 return 0;
 511             }
 512             rctx->mgf1md = p2;
 513         }
 514         return 1;
 515
 516     case EVP_PKEY_CTRL_RSA_OAEP_LABEL:
 517         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 518             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 519             return -2;
 520         }
 521         OPENSSL_free(rctx->oaep_label);
 522         if (p2 && p1 > 0) {
 523             rctx->oaep_label = p2;
 524             rctx->oaep_labellen = p1;
 525         } else {
 526             rctx->oaep_label = NULL;
 527             rctx->oaep_labellen = 0;
 528         }
 529         return 1;
 530
 531     case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
 532         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 533             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 534             return -2;
 535         }
 536         *(unsigned char **)p2 = rctx->oaep_label;
 537         return rctx->oaep_labellen;
 538
 539     case EVP_PKEY_CTRL_DIGESTINIT:
 540     case EVP_PKEY_CTRL_PKCS7_SIGN:
 541 #ifndef OPENSSL_NO_CMS
 542     case EVP_PKEY_CTRL_CMS_SIGN:
 543 #endif
 544     return 1;
 545
 546     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 547     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 548 #ifndef OPENSSL_NO_CMS
 549     case EVP_PKEY_CTRL_CMS_DECRYPT:
 550     case EVP_PKEY_CTRL_CMS_ENCRYPT:
 551 #endif
 552     if (!pkey_ctx_is_pss(ctx))
 553         return 1;
 554     /* fall through */
 555     case EVP_PKEY_CTRL_PEER_KEY:
 556         RSAerr(RSA_F_PKEY_RSA_CTRL,
 557                RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 558         return -2;
 559
 560     default:
 561         return -2;
 562
 563     }
 564 }
 565
 566 static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 567                              const char *type, const char *value)
 568 {
 569     if (value == NULL) {
 570         RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
 571         return 0;
 572     }
 573     if (strcmp(type, "rsa_padding_mode") == 0) {
 574         int pm;
 575         if (strcmp(value, "pkcs1") == 0)
 576             pm = RSA_PKCS1_PADDING;
 577         else if (strcmp(value, "sslv23") == 0)
 578             pm = RSA_SSLV23_PADDING;
 579         else if (strcmp(value, "none") == 0)
 580             pm = RSA_NO_PADDING;
 581         else if (strcmp(value, "oeap") == 0)
 582             pm = RSA_PKCS1_OAEP_PADDING;
 583         else if (strcmp(value, "oaep") == 0)
 584             pm = RSA_PKCS1_OAEP_PADDING;
 585         else if (strcmp(value, "x931") == 0)
 586             pm = RSA_X931_PADDING;
 587         else if (strcmp(value, "pss") == 0)
 588             pm = RSA_PKCS1_PSS_PADDING;
 589         else {
 590             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_UNKNOWN_PADDING_TYPE);
 591             return -2;
 592         }
 593         return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
 594     }
 595
 596     if (strcmp(type, "rsa_pss_saltlen") == 0) {
 597         int saltlen;
 598         if (!strcmp(value, "digest"))
 599             saltlen = RSA_PSS_SALTLEN_DIGEST;
 600         else if (!strcmp(value, "max"))
 601             saltlen = RSA_PSS_SALTLEN_MAX;
 602         else if (!strcmp(value, "auto"))
 603             saltlen = RSA_PSS_SALTLEN_AUTO;
 604         else
 605             saltlen = atoi(value);
 606         return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
 607     }
 608
 609     if (strcmp(type, "rsa_keygen_bits") == 0) {
 610         int nbits;
 611         nbits = atoi(value);
 612         return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits);
 613     }
 614
 615     if (strcmp(type, "rsa_keygen_pubexp") == 0) {
 616         int ret;
 617         BIGNUM *pubexp = NULL;
 618         if (!BN_asc2bn(&pubexp, value))
 619             return 0;
 620         ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
 621         if (ret <= 0)
 622             BN_free(pubexp);
 623         return ret;
 624     }
 625
 626     if (strcmp(type, "rsa_mgf1_md") == 0)
 627         return EVP_PKEY_CTX_md(ctx,
 628                                EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
 629                                EVP_PKEY_CTRL_RSA_MGF1_MD, value);
 630
 631     if (pkey_ctx_is_pss(ctx)) {
 632
 633         if (strcmp(type, "rsa_pss_keygen_mgf1_md") == 0)
 634             return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_KEYGEN,
 635                                    EVP_PKEY_CTRL_RSA_MGF1_MD, value);
 636
 637         if (strcmp(type, "rsa_pss_keygen_md") == 0)
 638             return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_KEYGEN,
 639                                    EVP_PKEY_CTRL_MD, value);
 640
 641         if (strcmp(type, "rsa_pss_keygen_saltlen") == 0) {
 642             int saltlen = atoi(value);
 643
 644             return EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(ctx, saltlen);
 645         }
 646     }
 647
 648     if (strcmp(type, "rsa_oaep_md") == 0)
 649         return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_CRYPT,
 650                                EVP_PKEY_CTRL_RSA_OAEP_MD, value);
 651
 652     if (strcmp(type, "rsa_oaep_label") == 0) {
 653         unsigned char *lab;
 654         long lablen;
 655         int ret;
 656         lab = OPENSSL_hexstr2buf(value, &lablen);
 657         if (!lab)
 658             return 0;
 659         ret = EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, lab, lablen);
 660         if (ret <= 0)
 661             OPENSSL_free(lab);
 662         return ret;
 663     }
 664
 665     return -2;
 666 }
 667
 668 /* Set PSS parameters when generating a key, if necessary */
 669 static int rsa_set_pss_param(RSA *rsa, EVP_PKEY_CTX *ctx)
 670 {
 671     RSA_PKEY_CTX *rctx = ctx->data;
 672
 673     if (!pkey_ctx_is_pss(ctx))
 674         return 1;
 675     /* If all parameters are default values don't set pss */
 676     if (rctx->md == NULL && rctx->mgf1md == NULL && rctx->saltlen == -2)
 677         return 1;
 678     rsa->pss = rsa_pss_params_create(rctx->md, rctx->mgf1md,
 679                                      rctx->saltlen == -2 ? 0 : rctx->saltlen);
 680     if (rsa->pss == NULL)
 681         return 0;
 682     return 1;
 683 }
 684
 685 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 686 {
 687     RSA *rsa = NULL;
 688     RSA_PKEY_CTX *rctx = ctx->data;
 689     BN_GENCB *pcb;
 690     int ret;
 691
 692     if (rctx->pub_exp == NULL) {
 693         rctx->pub_exp = BN_new();
 694         if (rctx->pub_exp == NULL || !BN_set_word(rctx->pub_exp, RSA_F4))
 695             return 0;
 696     }
 697     rsa = RSA_new();
 698     if (rsa == NULL)
 699         return 0;
 700     if (ctx->pkey_gencb) {
 701         pcb = BN_GENCB_new();
 702         if (pcb == NULL) {
 703             RSA_free(rsa);
 704             return 0;
 705         }
 706         evp_pkey_set_cb_translate(pcb, ctx);
 707     } else
 708         pcb = NULL;
 709     ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
 710     BN_GENCB_free(pcb);
 711     if (ret > 0 && !rsa_set_pss_param(rsa, ctx)) {
 712         RSA_free(rsa);
 713         return 0;
 714     }
 715     if (ret > 0)
 716         EVP_PKEY_assign(pkey, ctx->pmeth->pkey_id, rsa);
 717     else
 718         RSA_free(rsa);
 719     return ret;
 720 }
 721
 722 const EVP_PKEY_METHOD rsa_pkey_meth = {
 723     EVP_PKEY_RSA,
 724     EVP_PKEY_FLAG_AUTOARGLEN,
 725     pkey_rsa_init,
 726     pkey_rsa_copy,
 727     pkey_rsa_cleanup,
 728
 729     0, 0,
 730
 731     0,
 732     pkey_rsa_keygen,
 733
 734     0,
 735     pkey_rsa_sign,
 736
 737     0,
 738     pkey_rsa_verify,
 739
 740     0,
 741     pkey_rsa_verifyrecover,
 742
 743     0, 0, 0, 0,
 744
 745     0,
 746     pkey_rsa_encrypt,
 747
 748     0,
 749     pkey_rsa_decrypt,
 750
 751     0, 0,
 752
 753     pkey_rsa_ctrl,
 754     pkey_rsa_ctrl_str
 755 };
 756
 757 /*
 758  * Called for PSS sign or verify initialisation: checks PSS parameter
 759  * sanity and sets any restrictions on key usage.
 760  */
 761
 762 static int pkey_pss_init(EVP_PKEY_CTX *ctx)
 763 {
 764     RSA *rsa;
 765     RSA_PKEY_CTX *rctx = ctx->data;
 766     const EVP_MD *md;
 767     const EVP_MD *mgf1md;
 768     int min_saltlen, max_saltlen;
 769
 770     /* Should never happen */
 771     if (!pkey_ctx_is_pss(ctx))
 772         return 0;
 773     rsa = ctx->pkey->pkey.rsa;
 774     /* If no restrictions just return */
 775     if (rsa->pss == NULL)
 776         return 1;
 777     /* Get and check parameters */
 778     if (!rsa_pss_get_param(rsa->pss, &md, &mgf1md, &min_saltlen))
 779         return 0;
 780
 781     /* See if minumum salt length exceeds maximum possible */
 782     max_saltlen = RSA_size(rsa) - EVP_MD_size(md);
 783     if ((RSA_bits(rsa) & 0x7) == 1)
 784         max_saltlen--;
 785     if (min_saltlen > max_saltlen) {
 786         RSAerr(RSA_F_PKEY_PSS_INIT, RSA_R_INVALID_SALT_LENGTH);
 787         return 0;
 788     }
 789
 790     rctx->min_saltlen = min_saltlen;
 791
 792     /*
 793      * Set PSS restrictions as defaults: we can then block any attempt to
 794      * use invalid values in pkey_rsa_ctrl
 795      */
 796
 797     rctx->md = md;
 798     rctx->mgf1md = mgf1md;
 799     rctx->saltlen = min_saltlen;
 800
 801     return 1;
 802 }
 803
 804 const EVP_PKEY_METHOD rsa_pss_pkey_meth = {
 805     EVP_PKEY_RSA_PSS,
 806     EVP_PKEY_FLAG_AUTOARGLEN,
 807     pkey_rsa_init,
 808     pkey_rsa_copy,
 809     pkey_rsa_cleanup,
 810
 811     0, 0,
 812
 813     0,
 814     pkey_rsa_keygen,
 815
 816     pkey_pss_init,
 817     pkey_rsa_sign,
 818
 819     pkey_pss_init,
 820     pkey_rsa_verify,
 821
 822     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 823
 824     pkey_rsa_ctrl,
 825     pkey_rsa_ctrl_str
 826 };