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