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)) {
 436                 if (p1 == -2 && ctx->operation == EVP_PKEY_OP_VERIFY) {
 437                     RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
 438                     return -2;
 439                 }
 440                 if ((p1 == -1 && rctx->min_saltlen > EVP_MD_size(rctx->md))
 441                     || (p1 >= 0 && p1 < rctx->min_saltlen)) {
 442                     RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_PSS_SALTLEN_TOO_SMALL);
 443                     return 0;
 444                 }
 445             }
 446             rctx->saltlen = p1;
 447         }
 448         return 1;
 449
 450     case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
 451         if (p1 < 512) {
 452             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_KEY_SIZE_TOO_SMALL);
 453             return -2;
 454         }
 455         rctx->nbits = p1;
 456         return 1;
 457
 458     case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
 459         if (p2 == NULL || !BN_is_odd((BIGNUM *)p2) || BN_is_one((BIGNUM *)p2)) {
 460             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_BAD_E_VALUE);
 461             return -2;
 462         }
 463         BN_free(rctx->pub_exp);
 464         rctx->pub_exp = p2;
 465         return 1;
 466
 467     case EVP_PKEY_CTRL_RSA_OAEP_MD:
 468     case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
 469         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 470             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 471             return -2;
 472         }
 473         if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD)
 474             *(const EVP_MD **)p2 = rctx->md;
 475         else
 476             rctx->md = p2;
 477         return 1;
 478
 479     case EVP_PKEY_CTRL_MD:
 480         if (!check_padding_md(p2, rctx->pad_mode))
 481             return 0;
 482         if (rsa_pss_restricted(rctx)) {
 483             if (EVP_MD_type(rctx->md) == EVP_MD_type(p2))
 484                 return 1;
 485             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_DIGEST_NOT_ALLOWED);
 486             return 0;
 487         }
 488         rctx->md = p2;
 489         return 1;
 490
 491     case EVP_PKEY_CTRL_GET_MD:
 492         *(const EVP_MD **)p2 = rctx->md;
 493         return 1;
 494
 495     case EVP_PKEY_CTRL_RSA_MGF1_MD:
 496     case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
 497         if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING
 498             && rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 499             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD);
 500             return -2;
 501         }
 502         if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD) {
 503             if (rctx->mgf1md)
 504                 *(const EVP_MD **)p2 = rctx->mgf1md;
 505             else
 506                 *(const EVP_MD **)p2 = rctx->md;
 507         } else {
 508             if (rsa_pss_restricted(rctx)) {
 509                 if (EVP_MD_type(rctx->md) == EVP_MD_type(p2))
 510                     return 1;
 511                 RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_MGF1_DIGEST_NOT_ALLOWED);
 512                 return 0;
 513             }
 514             rctx->mgf1md = p2;
 515         }
 516         return 1;
 517
 518     case EVP_PKEY_CTRL_RSA_OAEP_LABEL:
 519         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 520             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 521             return -2;
 522         }
 523         OPENSSL_free(rctx->oaep_label);
 524         if (p2 && p1 > 0) {
 525             rctx->oaep_label = p2;
 526             rctx->oaep_labellen = p1;
 527         } else {
 528             rctx->oaep_label = NULL;
 529             rctx->oaep_labellen = 0;
 530         }
 531         return 1;
 532
 533     case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
 534         if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING) {
 535             RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
 536             return -2;
 537         }
 538         *(unsigned char **)p2 = rctx->oaep_label;
 539         return rctx->oaep_labellen;
 540
 541     case EVP_PKEY_CTRL_DIGESTINIT:
 542     case EVP_PKEY_CTRL_PKCS7_SIGN:
 543 #ifndef OPENSSL_NO_CMS
 544     case EVP_PKEY_CTRL_CMS_SIGN:
 545 #endif
 546     return 1;
 547
 548     case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
 549     case EVP_PKEY_CTRL_PKCS7_DECRYPT:
 550 #ifndef OPENSSL_NO_CMS
 551     case EVP_PKEY_CTRL_CMS_DECRYPT:
 552     case EVP_PKEY_CTRL_CMS_ENCRYPT:
 553     if (!pkey_ctx_is_pss(ctx))
 554         return 1;
 555 #endif
 556     case EVP_PKEY_CTRL_PEER_KEY:
 557         RSAerr(RSA_F_PKEY_RSA_CTRL,
 558                RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 559         return -2;
 560
 561     default:
 562         return -2;
 563
 564     }
 565 }
 566
 567 static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
 568                              const char *type, const char *value)
 569 {
 570     if (value == NULL) {
 571         RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
 572         return 0;
 573     }
 574     if (strcmp(type, "rsa_padding_mode") == 0) {
 575         int pm;
 576         if (strcmp(value, "pkcs1") == 0)
 577             pm = RSA_PKCS1_PADDING;
 578         else if (strcmp(value, "sslv23") == 0)
 579             pm = RSA_SSLV23_PADDING;
 580         else if (strcmp(value, "none") == 0)
 581             pm = RSA_NO_PADDING;
 582         else if (strcmp(value, "oeap") == 0)
 583             pm = RSA_PKCS1_OAEP_PADDING;
 584         else if (strcmp(value, "oaep") == 0)
 585             pm = RSA_PKCS1_OAEP_PADDING;
 586         else if (strcmp(value, "x931") == 0)
 587             pm = RSA_X931_PADDING;
 588         else if (strcmp(value, "pss") == 0)
 589             pm = RSA_PKCS1_PSS_PADDING;
 590         else {
 591             RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_UNKNOWN_PADDING_TYPE);
 592             return -2;
 593         }
 594         return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
 595     }
 596
 597     if (strcmp(type, "rsa_pss_saltlen") == 0) {
 598         int saltlen;
 599         saltlen = atoi(value);
 600         return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
 601     }
 602
 603     if (strcmp(type, "rsa_keygen_bits") == 0) {
 604         int nbits;
 605         nbits = atoi(value);
 606         return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits);
 607     }
 608
 609     if (strcmp(type, "rsa_keygen_pubexp") == 0) {
 610         int ret;
 611         BIGNUM *pubexp = NULL;
 612         if (!BN_asc2bn(&pubexp, value))
 613             return 0;
 614         ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
 615         if (ret <= 0)
 616             BN_free(pubexp);
 617         return ret;
 618     }
 619
 620     if (strcmp(type, "rsa_mgf1_md") == 0)
 621         return EVP_PKEY_CTX_md(ctx,
 622                                EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT,
 623                                EVP_PKEY_CTRL_RSA_MGF1_MD, value);
 624
 625     if (pkey_ctx_is_pss(ctx)) {
 626
 627         if (strcmp(type, "rsa_pss_keygen_mgf1_md") == 0)
 628             return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_KEYGEN,
 629                                    EVP_PKEY_CTRL_RSA_MGF1_MD, value);
 630
 631         if (strcmp(type, "rsa_pss_keygen_md") == 0)
 632             return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_KEYGEN,
 633                                    EVP_PKEY_CTRL_MD, value);
 634
 635         if (strcmp(type, "rsa_pss_keygen_saltlen") == 0) {
 636             int saltlen = atoi(value);
 637
 638             return EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(ctx, saltlen);
 639         }
 640     }
 641
 642     if (strcmp(type, "rsa_oaep_md") == 0)
 643         return EVP_PKEY_CTX_md(ctx, EVP_PKEY_OP_TYPE_CRYPT,
 644                                EVP_PKEY_CTRL_RSA_OAEP_MD, value);
 645
 646     if (strcmp(type, "rsa_oaep_label") == 0) {
 647         unsigned char *lab;
 648         long lablen;
 649         int ret;
 650         lab = OPENSSL_hexstr2buf(value, &lablen);
 651         if (!lab)
 652             return 0;
 653         ret = EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, lab, lablen);
 654         if (ret <= 0)
 655             OPENSSL_free(lab);
 656         return ret;
 657     }
 658
 659     return -2;
 660 }
 661
 662 /* Set PSS parameters when generating a key, if necessary */
 663 static int rsa_set_pss_param(RSA *rsa, EVP_PKEY_CTX *ctx)
 664 {
 665     RSA_PKEY_CTX *rctx = ctx->data;
 666
 667     if (!pkey_ctx_is_pss(ctx))
 668         return 1;
 669     /* If all parameters are default values don't set pss */
 670     if (rctx->md == NULL && rctx->mgf1md == NULL && rctx->saltlen == -2)
 671         return 1;
 672     rsa->pss = rsa_pss_params_create(rctx->md, rctx->mgf1md,
 673                                      rctx->saltlen == -2 ? 0 : rctx->saltlen);
 674     if (rsa->pss == NULL)
 675         return 0;
 676     return 1;
 677 }
 678
 679 static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 680 {
 681     RSA *rsa = NULL;
 682     RSA_PKEY_CTX *rctx = ctx->data;
 683     BN_GENCB *pcb;
 684     int ret;
 685
 686     if (rctx->pub_exp == NULL) {
 687         rctx->pub_exp = BN_new();
 688         if (rctx->pub_exp == NULL || !BN_set_word(rctx->pub_exp, RSA_F4))
 689             return 0;
 690     }
 691     rsa = RSA_new();
 692     if (rsa == NULL)
 693         return 0;
 694     if (ctx->pkey_gencb) {
 695         pcb = BN_GENCB_new();
 696         if (pcb == NULL) {
 697             RSA_free(rsa);
 698             return 0;
 699         }
 700         evp_pkey_set_cb_translate(pcb, ctx);
 701     } else
 702         pcb = NULL;
 703     ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
 704     BN_GENCB_free(pcb);
 705     if (ret > 0 && !rsa_set_pss_param(rsa, ctx)) {
 706         RSA_free(rsa);
 707         return 0;
 708     }
 709     if (ret > 0)
 710         EVP_PKEY_assign(pkey, ctx->pmeth->pkey_id, rsa);
 711     else
 712         RSA_free(rsa);
 713     return ret;
 714 }
 715
 716 const EVP_PKEY_METHOD rsa_pkey_meth = {
 717     EVP_PKEY_RSA,
 718     EVP_PKEY_FLAG_AUTOARGLEN,
 719     pkey_rsa_init,
 720     pkey_rsa_copy,
 721     pkey_rsa_cleanup,
 722
 723     0, 0,
 724
 725     0,
 726     pkey_rsa_keygen,
 727
 728     0,
 729     pkey_rsa_sign,
 730
 731     0,
 732     pkey_rsa_verify,
 733
 734     0,
 735     pkey_rsa_verifyrecover,
 736
 737     0, 0, 0, 0,
 738
 739     0,
 740     pkey_rsa_encrypt,
 741
 742     0,
 743     pkey_rsa_decrypt,
 744
 745     0, 0,
 746
 747     pkey_rsa_ctrl,
 748     pkey_rsa_ctrl_str
 749 };
 750
 751 /*
 752  * Called for PSS sign or verify initialisation: checks PSS parameter
 753  * sanity and sets any restrictions on key usage.
 754  */
 755
 756 static int pkey_pss_init(EVP_PKEY_CTX *ctx)
 757 {
 758     RSA *rsa;
 759     RSA_PKEY_CTX *rctx = ctx->data;
 760     const EVP_MD *md;
 761     const EVP_MD *mgf1md;
 762     int min_saltlen, max_saltlen;
 763
 764     /* Should never happen */
 765     if (!pkey_ctx_is_pss(ctx))
 766         return 0;
 767     rsa = ctx->pkey->pkey.rsa;
 768     /* If no restrictions just return */
 769     if (rsa->pss == NULL)
 770         return 1;
 771     /* Get and check parameters */
 772     if (!rsa_pss_get_param(rsa->pss, &md, &mgf1md, &min_saltlen))
 773         return 0;
 774
 775     /* See if minumum salt length exceeds maximum possible */
 776     max_saltlen = RSA_size(rsa) - EVP_MD_size(md);
 777     if ((RSA_bits(rsa) & 0x7) == 1)
 778         max_saltlen--;
 779     if (min_saltlen > max_saltlen) {
 780         RSAerr(RSA_F_PKEY_PSS_INIT, RSA_R_INVALID_SALT_LENGTH);
 781         return 0;
 782     }
 783
 784     rctx->min_saltlen = min_saltlen;
 785
 786     /*
 787      * Set PSS restrictions as defaults: we can then block any attempt to
 788      * use invalid values in pkey_rsa_ctrl
 789      */
 790
 791     rctx->md = md;
 792     rctx->mgf1md = mgf1md;
 793     rctx->saltlen = min_saltlen;
 794
 795     return 1;
 796 }
 797
 798 const EVP_PKEY_METHOD rsa_pss_pkey_meth = {
 799     EVP_PKEY_RSA_PSS,
 800     EVP_PKEY_FLAG_AUTOARGLEN,
 801     pkey_rsa_init,
 802     pkey_rsa_copy,
 803     pkey_rsa_cleanup,
 804
 805     0, 0,
 806
 807     0,
 808     pkey_rsa_keygen,
 809
 810     pkey_pss_init,
 811     pkey_rsa_sign,
 812
 813     pkey_pss_init,
 814     pkey_rsa_verify,
 815
 816     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 817
 818     pkey_rsa_ctrl,
 819     pkey_rsa_ctrl_str
 820 };