crypto/rsa/rsa_pmeth.c

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