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