crypto/rsa/rsa_ameth.c

   1 /* crypto/rsa/rsa_ameth.c */
   2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project 2006.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <stdio.h>
  60 #include "cryptlib.h"
  61 #include <openssl/asn1t.h>
  62 #include <openssl/x509.h>
  63 #include <openssl/rsa.h>
  64 #include <openssl/bn.h>
  65 #ifndef OPENSSL_NO_CMS
  66 #include <openssl/cms.h>
  67 #endif
  68 #include "asn1_locl.h"
  69
  70 static int rsa_cms_sign(CMS_SignerInfo *si);
  71 static int rsa_cms_verify(CMS_SignerInfo *si);
  72 static int rsa_cms_decrypt(CMS_RecipientInfo *ri);
  73 static int rsa_cms_encrypt(CMS_RecipientInfo *ri);
  74
  75 static int rsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
  76         {
  77         unsigned char *penc = NULL;
  78         int penclen;
  79         penclen = i2d_RSAPublicKey(pkey->pkey.rsa, &penc);
  80         if (penclen <= 0)
  81                 return 0;
  82         if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_RSA),
  83                                 V_ASN1_NULL, NULL, penc, penclen))
  84                 return 1;
  85
  86         OPENSSL_free(penc);
  87         return 0;
  88         }
  89
  90 static int rsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
  91         {
  92         const unsigned char *p;
  93         int pklen;
  94         RSA *rsa = NULL;
  95         if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, NULL, pubkey))
  96                 return 0;
  97         if (!(rsa = d2i_RSAPublicKey(NULL, &p, pklen)))
  98                 {
  99                 RSAerr(RSA_F_RSA_PUB_DECODE, ERR_R_RSA_LIB);
 100                 return 0;
 101                 }
 102         EVP_PKEY_assign_RSA (pkey, rsa);
 103         return 1;
 104         }
 105
 106 static int rsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
 107         {
 108         if (BN_cmp(b->pkey.rsa->n,a->pkey.rsa->n) != 0
 109                 || BN_cmp(b->pkey.rsa->e,a->pkey.rsa->e) != 0)
 110                         return 0;
 111         return 1;
 112         }
 113
 114 static int old_rsa_priv_decode(EVP_PKEY *pkey,
 115                                         const unsigned char **pder, int derlen)
 116         {
 117         RSA *rsa;
 118         if (!(rsa = d2i_RSAPrivateKey (NULL, pder, derlen)))
 119                 {
 120                 RSAerr(RSA_F_OLD_RSA_PRIV_DECODE, ERR_R_RSA_LIB);
 121                 return 0;
 122                 }
 123         EVP_PKEY_assign_RSA(pkey, rsa);
 124         return 1;
 125         }
 126
 127 static int old_rsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
 128         {
 129         return i2d_RSAPrivateKey(pkey->pkey.rsa, pder);
 130         }
 131
 132 static int rsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
 133         {
 134         unsigned char *rk = NULL;
 135         int rklen;
 136         rklen = i2d_RSAPrivateKey(pkey->pkey.rsa, &rk);
 137
 138         if (rklen <= 0)
 139                 {
 140                 RSAerr(RSA_F_RSA_PRIV_ENCODE,ERR_R_MALLOC_FAILURE);
 141                 return 0;
 142                 }
 143
 144         if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_rsaEncryption), 0,
 145                                 V_ASN1_NULL, NULL, rk, rklen))
 146                 {
 147                 RSAerr(RSA_F_RSA_PRIV_ENCODE,ERR_R_MALLOC_FAILURE);
 148                 return 0;
 149                 }
 150
 151         return 1;
 152         }
 153
 154 static int rsa_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
 155         {
 156         const unsigned char *p;
 157         int pklen;
 158         if (!PKCS8_pkey_get0(NULL, &p, &pklen, NULL, p8))
 159                 return 0;
 160         return old_rsa_priv_decode(pkey, &p, pklen);
 161         }
 162
 163 static int int_rsa_size(const EVP_PKEY *pkey)
 164         {
 165         return RSA_size(pkey->pkey.rsa);
 166         }
 167
 168 static int rsa_bits(const EVP_PKEY *pkey)
 169         {
 170         return BN_num_bits(pkey->pkey.rsa->n);
 171         }
 172
 173 static int rsa_security_bits(const EVP_PKEY *pkey)
 174         {
 175         return RSA_security_bits(pkey->pkey.rsa);
 176         }
 177
 178 static void int_rsa_free(EVP_PKEY *pkey)
 179         {
 180         RSA_free(pkey->pkey.rsa);
 181         }
 182
 183
 184 static void update_buflen(const BIGNUM *b, size_t *pbuflen)
 185         {
 186         size_t i;
 187         if (!b)
 188                 return;
 189         if (*pbuflen < (i = (size_t)BN_num_bytes(b)))
 190                         *pbuflen = i;
 191         }
 192
 193 static int do_rsa_print(BIO *bp, const RSA *x, int off, int priv)
 194         {
 195         char *str;
 196         const char *s;
 197         unsigned char *m=NULL;
 198         int ret=0, mod_len = 0;
 199         size_t buf_len=0;
 200
 201         update_buflen(x->n, &buf_len);
 202         update_buflen(x->e, &buf_len);
 203
 204         if (priv)
 205                 {
 206                 update_buflen(x->d, &buf_len);
 207                 update_buflen(x->p, &buf_len);
 208                 update_buflen(x->q, &buf_len);
 209                 update_buflen(x->dmp1, &buf_len);
 210                 update_buflen(x->dmq1, &buf_len);
 211                 update_buflen(x->iqmp, &buf_len);
 212                 }
 213
 214         m=(unsigned char *)OPENSSL_malloc(buf_len+10);
 215         if (m == NULL)
 216                 {
 217                 RSAerr(RSA_F_DO_RSA_PRINT,ERR_R_MALLOC_FAILURE);
 218                 goto err;
 219                 }
 220
 221         if (x->n != NULL)
 222                 mod_len = BN_num_bits(x->n);
 223
 224         if(!BIO_indent(bp,off,128))
 225                 goto err;
 226
 227         if (priv && x->d)
 228                 {
 229                 if (BIO_printf(bp,"Private-Key: (%d bit)\n", mod_len)
 230                         <= 0) goto err;
 231                 str = "modulus:";
 232                 s = "publicExponent:";
 233                 }
 234         else
 235                 {
 236                 if (BIO_printf(bp,"Public-Key: (%d bit)\n", mod_len)
 237                         <= 0) goto err;
 238                 str = "Modulus:";
 239                 s= "Exponent:";
 240                 }
 241         if (!ASN1_bn_print(bp,str,x->n,m,off)) goto err;
 242         if (!ASN1_bn_print(bp,s,x->e,m,off))
 243                 goto err;
 244         if (priv)
 245                 {
 246                 if (!ASN1_bn_print(bp,"privateExponent:",x->d,m,off))
 247                         goto err;
 248                 if (!ASN1_bn_print(bp,"prime1:",x->p,m,off))
 249                         goto err;
 250                 if (!ASN1_bn_print(bp,"prime2:",x->q,m,off))
 251                         goto err;
 252                 if (!ASN1_bn_print(bp,"exponent1:",x->dmp1,m,off))
 253                         goto err;
 254                 if (!ASN1_bn_print(bp,"exponent2:",x->dmq1,m,off))
 255                         goto err;
 256                 if (!ASN1_bn_print(bp,"coefficient:",x->iqmp,m,off))
 257                         goto err;
 258                 }
 259         ret=1;
 260 err:
 261         if (m != NULL) OPENSSL_free(m);
 262         return(ret);
 263         }
 264
 265 static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
 266                                                         ASN1_PCTX *ctx)
 267         {
 268         return do_rsa_print(bp, pkey->pkey.rsa, indent, 0);
 269         }
 270
 271
 272 static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
 273                                                         ASN1_PCTX *ctx)
 274         {
 275         return do_rsa_print(bp, pkey->pkey.rsa, indent, 1);
 276         }
 277
 278 /* Given an MGF1 Algorithm ID decode to an Algorithm Identifier */
 279 static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
 280         {
 281         const unsigned char *p;
 282         int plen;
 283         if (alg == NULL)
 284                 return NULL;
 285         if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
 286                 return NULL;
 287         if (alg->parameter->type != V_ASN1_SEQUENCE)
 288                 return NULL;
 289
 290         p = alg->parameter->value.sequence->data;
 291         plen = alg->parameter->value.sequence->length;
 292         return d2i_X509_ALGOR(NULL, &p, plen);
 293         }
 294
 295 static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
 296                                         X509_ALGOR **pmaskHash)
 297         {
 298         const unsigned char *p;
 299         int plen;
 300         RSA_PSS_PARAMS *pss;
 301
 302         *pmaskHash = NULL;
 303
 304         if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
 305                 return NULL;
 306         p = alg->parameter->value.sequence->data;
 307         plen = alg->parameter->value.sequence->length;
 308         pss = d2i_RSA_PSS_PARAMS(NULL, &p, plen);
 309
 310         if (!pss)
 311                 return NULL;
 312
 313         *pmaskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
 314
 315         return pss;
 316         }
 317
 318 static int rsa_pss_param_print(BIO *bp, RSA_PSS_PARAMS *pss,
 319                                 X509_ALGOR *maskHash, int indent)
 320         {
 321         int rv = 0;
 322         if (!pss)
 323                 {
 324                 if (BIO_puts(bp, " (INVALID PSS PARAMETERS)\n") <= 0)
 325                         return 0;
 326                 return 1;
 327                 }
 328         if (BIO_puts(bp, "\n") <= 0)
 329                 goto err;
 330         if (!BIO_indent(bp, indent, 128))
 331                 goto err;
 332         if (BIO_puts(bp, "Hash Algorithm: ") <= 0)
 333                 goto err;
 334
 335         if (pss->hashAlgorithm)
 336                 {
 337                 if (i2a_ASN1_OBJECT(bp, pss->hashAlgorithm->algorithm) <= 0)
 338                         goto err;
 339                 }
 340         else if (BIO_puts(bp, "sha1 (default)") <= 0)
 341                 goto err;
 342
 343         if (BIO_puts(bp, "\n") <= 0)
 344                 goto err;
 345
 346         if (!BIO_indent(bp, indent, 128))
 347                 goto err;
 348
 349         if (BIO_puts(bp, "Mask Algorithm: ") <= 0)
 350                         goto err;
 351         if (pss->maskGenAlgorithm)
 352                 {
 353                 if (i2a_ASN1_OBJECT(bp, pss->maskGenAlgorithm->algorithm) <= 0)
 354                         goto err;
 355                 if (BIO_puts(bp, " with ") <= 0)
 356                         goto err;
 357                 if (maskHash)
 358                         {
 359                         if (i2a_ASN1_OBJECT(bp, maskHash->algorithm) <= 0)
 360                         goto err;
 361                         }
 362                 else if (BIO_puts(bp, "INVALID") <= 0)
 363                         goto err;
 364                 }
 365         else if (BIO_puts(bp, "mgf1 with sha1 (default)") <= 0)
 366                 goto err;
 367         BIO_puts(bp, "\n");
 368
 369         if (!BIO_indent(bp, indent, 128))
 370                 goto err;
 371         if (BIO_puts(bp, "Salt Length: 0x") <= 0)
 372                         goto err;
 373         if (pss->saltLength)
 374                 {
 375                 if (i2a_ASN1_INTEGER(bp, pss->saltLength) <= 0)
 376                         goto err;
 377                 }
 378         else if (BIO_puts(bp, "14 (default)") <= 0)
 379                 goto err;
 380         BIO_puts(bp, "\n");
 381
 382         if (!BIO_indent(bp, indent, 128))
 383                 goto err;
 384         if (BIO_puts(bp, "Trailer Field: 0x") <= 0)
 385                         goto err;
 386         if (pss->trailerField)
 387                 {
 388                 if (i2a_ASN1_INTEGER(bp, pss->trailerField) <= 0)
 389                         goto err;
 390                 }
 391         else if (BIO_puts(bp, "BC (default)") <= 0)
 392                 goto err;
 393         BIO_puts(bp, "\n");
 394
 395         rv = 1;
 396
 397         err:
 398         return rv;
 399
 400         }
 401
 402 static int rsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
 403                                         const ASN1_STRING *sig,
 404                                         int indent, ASN1_PCTX *pctx)
 405         {
 406         if (OBJ_obj2nid(sigalg->algorithm) == NID_rsassaPss)
 407                 {
 408                 int rv;
 409                 RSA_PSS_PARAMS *pss;
 410                 X509_ALGOR *maskHash;
 411                 pss = rsa_pss_decode(sigalg, &maskHash);
 412                 rv = rsa_pss_param_print(bp, pss, maskHash, indent);
 413                 if (pss)
 414                         RSA_PSS_PARAMS_free(pss);
 415                 if (maskHash)
 416                         X509_ALGOR_free(maskHash);
 417                 if (!rv)
 418                         return 0;
 419                 }
 420         else if (!sig && BIO_puts(bp, "\n") <= 0)
 421                 return 0;
 422         if (sig)
 423                 return X509_signature_dump(bp, sig, indent);
 424         return 1;
 425         }
 426
 427 static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
 428         {
 429         X509_ALGOR *alg = NULL;
 430         switch (op)
 431                 {
 432
 433                 case ASN1_PKEY_CTRL_PKCS7_SIGN:
 434                 if (arg1 == 0)
 435                         PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
 436                 break;
 437
 438                 case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
 439                 if (arg1 == 0)
 440                         PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
 441                 break;
 442 #ifndef OPENSSL_NO_CMS
 443                 case ASN1_PKEY_CTRL_CMS_SIGN:
 444                 if (arg1 == 0)
 445                         return rsa_cms_sign(arg2);
 446                 else if (arg1 == 1)
 447                         return rsa_cms_verify(arg2);
 448                 break;
 449
 450                 case ASN1_PKEY_CTRL_CMS_ENVELOPE:
 451                 if (arg1 == 0)
 452                         return rsa_cms_encrypt(arg2);
 453                 else if (arg1 == 1)
 454                         return rsa_cms_decrypt(arg2);
 455                 break;
 456
 457                 case ASN1_PKEY_CTRL_CMS_RI_TYPE:
 458                 *(int *)arg2 = CMS_RECIPINFO_TRANS;
 459                 return 1;
 460 #endif
 461
 462                 case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
 463                 *(int *)arg2 = NID_sha256;
 464                 return 1;
 465
 466                 default:
 467                 return -2;
 468
 469                 }
 470
 471         if (alg)
 472                 X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption),
 473                                                         V_ASN1_NULL, 0);
 474
 475         return 1;
 476
 477         }
 478
 479 /* allocate and set algorithm ID from EVP_MD, default SHA1 */
 480 static int rsa_md_to_algor(X509_ALGOR **palg, const EVP_MD *md)
 481         {
 482         if (EVP_MD_type(md) == NID_sha1)
 483                 return 1;
 484         *palg = X509_ALGOR_new();
 485         if (!*palg)
 486                 return 0;
 487         X509_ALGOR_set_md(*palg, md);
 488         return 1;
 489         }
 490
 491 /* Allocate and set MGF1 algorithm ID from EVP_MD */
 492 static int rsa_md_to_mgf1(X509_ALGOR **palg, const EVP_MD *mgf1md)
 493         {
 494         X509_ALGOR *algtmp = NULL;
 495         ASN1_STRING *stmp = NULL;
 496         *palg = NULL;
 497         if (EVP_MD_type(mgf1md) == NID_sha1)
 498                 return 1;
 499         /* need to embed algorithm ID inside another */
 500         if (!rsa_md_to_algor(&algtmp, mgf1md))
 501                 goto err;
 502         if (!ASN1_item_pack(algtmp, ASN1_ITEM_rptr(X509_ALGOR), &stmp))
 503                         goto err;
 504         *palg = X509_ALGOR_new();
 505         if (!*palg)
 506                 goto err;
 507         X509_ALGOR_set0(*palg, OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
 508         stmp = NULL;
 509         err:
 510         if (stmp)
 511                 ASN1_STRING_free(stmp);
 512         if (algtmp)
 513                 X509_ALGOR_free(algtmp);
 514         if (*palg)
 515                 return 1;
 516         return 0;
 517         }
 518
 519 /* convert algorithm ID to EVP_MD, default SHA1 */
 520 static const EVP_MD *rsa_algor_to_md(X509_ALGOR *alg)
 521         {
 522         const EVP_MD *md;
 523         if (!alg)
 524                 return EVP_sha1();
 525         md = EVP_get_digestbyobj(alg->algorithm);
 526         if (md == NULL)
 527                 RSAerr(RSA_F_RSA_ALGOR_TO_MD, RSA_R_UNKNOWN_DIGEST);
 528         return md;
 529         }
 530 /* convert MGF1 algorithm ID to EVP_MD, default SHA1 */
 531 static const EVP_MD *rsa_mgf1_to_md(X509_ALGOR *alg, X509_ALGOR *maskHash)
 532         {
 533         const EVP_MD *md;
 534         if (!alg)
 535                 return EVP_sha1();
 536         /* Check mask and lookup mask hash algorithm */
 537         if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
 538                 {
 539                 RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_ALGORITHM);
 540                 return NULL;
 541                 }
 542         if (!maskHash)
 543                 {
 544                 RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_PARAMETER);
 545                 return NULL;
 546                 }
 547         md = EVP_get_digestbyobj(maskHash->algorithm);
 548         if (md == NULL)
 549                 {
 550                 RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNKNOWN_MASK_DIGEST);
 551                 return NULL;
 552                 }
 553         return md;
 554         }
 555
 556 /* Convert EVP_PKEY_CTX is PSS mode into corresponding algorithm parameter,
 557  * suitable for setting an AlgorithmIdentifier.
 558  */
 559
 560 static ASN1_STRING *rsa_ctx_to_pss(EVP_PKEY_CTX *pkctx)
 561         {
 562         const EVP_MD *sigmd, *mgf1md;
 563         RSA_PSS_PARAMS *pss = NULL;
 564         ASN1_STRING *os = NULL;
 565         EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(pkctx);
 566         int saltlen, rv = 0;
 567         if (EVP_PKEY_CTX_get_signature_md(pkctx, &sigmd) <= 0)
 568                 goto err;
 569         if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
 570                 goto err;
 571         if (!EVP_PKEY_CTX_get_rsa_pss_saltlen(pkctx, &saltlen))
 572                 goto err;
 573         if (saltlen == -1)
 574                 saltlen = EVP_MD_size(sigmd);
 575         else if (saltlen == -2)
 576                 {
 577                 saltlen = EVP_PKEY_size(pk) - EVP_MD_size(sigmd) - 2;
 578                 if (((EVP_PKEY_bits(pk) - 1) & 0x7) == 0)
 579                         saltlen--;
 580                 }
 581         pss = RSA_PSS_PARAMS_new();
 582         if (!pss)
 583                 goto err;
 584         if (saltlen != 20)
 585                 {
 586                 pss->saltLength = ASN1_INTEGER_new();
 587                 if (!pss->saltLength)
 588                         goto err;
 589                 if (!ASN1_INTEGER_set(pss->saltLength, saltlen))
 590                         goto err;
 591                 }
 592         if (!rsa_md_to_algor(&pss->hashAlgorithm, sigmd))
 593                 goto err;
 594         if (!rsa_md_to_mgf1(&pss->maskGenAlgorithm, mgf1md))
 595                 goto err;
 596         /* Finally create string with pss parameter encoding. */
 597         if (!ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), &os))
 598                 goto err;
 599         rv = 1;
 600         err:
 601         if (pss)
 602                 RSA_PSS_PARAMS_free(pss);
 603         if (rv)
 604                 return os;
 605         if (os)
 606                 ASN1_STRING_free(os);
 607         return NULL;
 608         }
 609
 610 /* From PSS AlgorithmIdentifier set public key parameters. If pkey
 611  * isn't NULL then the EVP_MD_CTX is setup and initalised. If it
 612  * is NULL parameters are passed to pkctx instead.
 613  */
 614
 615 static int rsa_pss_to_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pkctx,
 616                                 X509_ALGOR *sigalg, EVP_PKEY *pkey)
 617         {
 618         int rv = -1;
 619         int saltlen;
 620         const EVP_MD *mgf1md = NULL, *md = NULL;
 621         RSA_PSS_PARAMS *pss;
 622         X509_ALGOR *maskHash;
 623         /* Sanity check: make sure it is PSS */
 624         if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss)
 625                 {
 626                 RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
 627                 return -1;
 628                 }
 629         /* Decode PSS parameters */
 630         pss = rsa_pss_decode(sigalg, &maskHash);
 631
 632         if (pss == NULL)
 633                 {
 634                 RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_PSS_PARAMETERS);
 635                 goto err;
 636                 }
 637         mgf1md = rsa_mgf1_to_md(pss->maskGenAlgorithm, maskHash);
 638         if (!mgf1md)
 639                 goto err;
 640         md = rsa_algor_to_md(pss->hashAlgorithm);
 641         if (!md)
 642                 goto err;
 643
 644         if (pss->saltLength)
 645                 {
 646                 saltlen = ASN1_INTEGER_get(pss->saltLength);
 647
 648                 /* Could perform more salt length sanity checks but the main
 649                  * RSA routines will trap other invalid values anyway.
 650                  */
 651                 if (saltlen < 0)
 652                         {
 653                         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_SALT_LENGTH);
 654                         goto err;
 655                         }
 656                 }
 657         else
 658                 saltlen = 20;
 659
 660         /* low-level routines support only trailer field 0xbc (value 1)
 661          * and PKCS#1 says we should reject any other value anyway.
 662          */
 663         if (pss->trailerField && ASN1_INTEGER_get(pss->trailerField) != 1)
 664                 {
 665                 RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_TRAILER);
 666                 goto err;
 667                 }
 668
 669         /* We have all parameters now set up context */
 670
 671         if (pkey)
 672                 {
 673                 if (!EVP_DigestVerifyInit(ctx, &pkctx, md, NULL, pkey))
 674                         goto err;
 675                 }
 676         else
 677                 {
 678                 const EVP_MD *checkmd;
 679                 if (EVP_PKEY_CTX_get_signature_md(pkctx, &checkmd) <= 0)
 680                         goto err;
 681                 if (EVP_MD_type(md) != EVP_MD_type(checkmd))
 682                         {
 683                         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_DIGEST_DOES_NOT_MATCH);
 684                         goto err;
 685                         }
 686                 }
 687
 688         if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_PSS_PADDING) <= 0)
 689                 goto err;
 690
 691         if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkctx, saltlen) <= 0)
 692                 goto err;
 693
 694         if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
 695                 goto err;
 696         /* Carry on */
 697         rv = 1;
 698
 699         err:
 700         RSA_PSS_PARAMS_free(pss);
 701         if (maskHash)
 702                 X509_ALGOR_free(maskHash);
 703         return rv;
 704         }
 705
 706 static int rsa_cms_verify(CMS_SignerInfo *si)
 707         {
 708         int nid, nid2;
 709         X509_ALGOR *alg;
 710         EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
 711         CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
 712         nid = OBJ_obj2nid(alg->algorithm);
 713         if (nid == NID_rsaEncryption)
 714                 return 1;
 715         if (nid == NID_rsassaPss)
 716                 return rsa_pss_to_ctx(NULL, pkctx, alg, NULL);
 717         /* Workaround for some implementation that use a signature OID */
 718         if (OBJ_find_sigid_algs(nid, NULL, &nid2))
 719                 {
 720                 if (nid2 == NID_rsaEncryption)
 721                         return 1;
 722                 }
 723         return 0;
 724         }
 725
 726 /* Customised RSA item verification routine. This is called
 727  * when a signature is encountered requiring special handling. We
 728  * currently only handle PSS.
 729  */
 730
 731
 732 static int rsa_item_verify(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
 733                         X509_ALGOR *sigalg, ASN1_BIT_STRING *sig,
 734                         EVP_PKEY *pkey)
 735         {
 736         /* Sanity check: make sure it is PSS */
 737         if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss)
 738                 {
 739                 RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
 740                 return -1;
 741                 }
 742         if (rsa_pss_to_ctx(ctx, NULL, sigalg, pkey))
 743                 /* Carry on */
 744                 return 2;
 745         return -1;
 746         }
 747
 748 static int rsa_cms_sign(CMS_SignerInfo *si)
 749         {
 750         int pad_mode = RSA_PKCS1_PADDING;
 751         X509_ALGOR *alg;
 752         EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
 753         ASN1_STRING *os = NULL;
 754         CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
 755         if (pkctx)
 756                 {
 757                 if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
 758                         return 0;
 759                 }
 760         if (pad_mode == RSA_PKCS1_PADDING)
 761                 {
 762                 X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption),
 763                                                         V_ASN1_NULL, 0);
 764                 return 1;
 765                 }
 766         /* We don't support it */
 767         if (pad_mode != RSA_PKCS1_PSS_PADDING)
 768                 return 0;
 769         os = rsa_ctx_to_pss(pkctx);
 770         if (!os)
 771                 return 0;
 772         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsassaPss), V_ASN1_SEQUENCE, os);
 773         return 1;
 774         }
 775
 776 static int rsa_item_sign(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
 777                                 X509_ALGOR *alg1, X509_ALGOR *alg2,
 778                                 ASN1_BIT_STRING *sig)
 779         {
 780         int pad_mode;
 781         EVP_PKEY_CTX *pkctx = ctx->pctx;
 782         if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
 783                 return 0;
 784         if (pad_mode == RSA_PKCS1_PADDING)
 785                 return 2;
 786         if (pad_mode == RSA_PKCS1_PSS_PADDING)
 787                 {
 788                 ASN1_STRING *os1 = NULL;
 789                 os1 = rsa_ctx_to_pss(pkctx);
 790                 if (!os1)
 791                         return 0;
 792                 /* Duplicate parameters if we have to */
 793                 if (alg2)
 794                         {
 795                         ASN1_STRING *os2 = ASN1_STRING_dup(os1);
 796                         if (!os2)
 797                                 {
 798                                 ASN1_STRING_free(os1);
 799                                 return 0;
 800                                 }
 801                         X509_ALGOR_set0(alg2, OBJ_nid2obj(NID_rsassaPss),
 802                                                 V_ASN1_SEQUENCE, os2);
 803                         }
 804                 X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_rsassaPss),
 805                                         V_ASN1_SEQUENCE, os1);
 806                 return 3;
 807                 }
 808         return 2;
 809         }
 810
 811 static RSA_OAEP_PARAMS *rsa_oaep_decode(const X509_ALGOR *alg,
 812                                         X509_ALGOR **pmaskHash)
 813         {
 814         const unsigned char *p;
 815         int plen;
 816         RSA_OAEP_PARAMS *pss;
 817
 818         *pmaskHash = NULL;
 819
 820         if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
 821                 return NULL;
 822         p = alg->parameter->value.sequence->data;
 823         plen = alg->parameter->value.sequence->length;
 824         pss = d2i_RSA_OAEP_PARAMS(NULL, &p, plen);
 825
 826         if (!pss)
 827                 return NULL;
 828
 829         *pmaskHash = rsa_mgf1_decode(pss->maskGenFunc);
 830
 831         return pss;
 832         }
 833
 834 static int rsa_cms_decrypt(CMS_RecipientInfo *ri)
 835         {
 836         EVP_PKEY_CTX *pkctx;
 837         X509_ALGOR *cmsalg;
 838         int nid;
 839         int rv = -1;
 840         unsigned char *label = NULL;
 841         int labellen = 0;
 842         const EVP_MD *mgf1md = NULL, *md = NULL;
 843         RSA_OAEP_PARAMS *oaep;
 844         X509_ALGOR *maskHash;
 845         pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
 846         if (!pkctx)
 847                 return 0;
 848         if (!CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &cmsalg))
 849                 return -1;
 850         nid = OBJ_obj2nid(cmsalg->algorithm);
 851         if (nid == NID_rsaEncryption)
 852                 return 1;
 853         if (nid != NID_rsaesOaep)
 854                 {
 855                 RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_ENCRYPTION_TYPE);
 856                 return -1;
 857                 }
 858         /* Decode OAEP parameters */
 859         oaep = rsa_oaep_decode(cmsalg, &maskHash);
 860
 861         if (oaep == NULL)
 862                 {
 863                 RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_OAEP_PARAMETERS);
 864                 goto err;
 865                 }
 866
 867         mgf1md = rsa_mgf1_to_md(oaep->maskGenFunc, maskHash);
 868         if (!mgf1md)
 869                 goto err;
 870         md = rsa_algor_to_md(oaep->hashFunc);
 871         if (!md)
 872                 goto err;
 873
 874         if (oaep->pSourceFunc)
 875                 {
 876                 X509_ALGOR *plab = oaep->pSourceFunc;
 877                 if (OBJ_obj2nid(plab->algorithm) != NID_pSpecified)
 878                         {
 879                         RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_LABEL_SOURCE);
 880                         goto err;
 881                         }
 882                 if (plab->parameter->type != V_ASN1_OCTET_STRING)
 883                         {
 884                         RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_LABEL);
 885                         goto err;
 886                         }
 887
 888                 label = plab->parameter->value.octet_string->data;
 889                 /* Stop label being freed when OAEP parameters are freed */
 890                 plab->parameter->value.octet_string->data = NULL;
 891                 labellen = plab->parameter->value.octet_string->length;
 892                 }
 893
 894         if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_OAEP_PADDING) <= 0)
 895                 goto err;
 896         if (EVP_PKEY_CTX_set_rsa_oaep_md(pkctx, md) <= 0)
 897                 goto err;
 898         if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
 899                 goto err;
 900         if (EVP_PKEY_CTX_set0_rsa_oaep_label(pkctx, label, labellen) <= 0)
 901                 goto err;
 902         /* Carry on */
 903         rv = 1;
 904
 905         err:
 906         RSA_OAEP_PARAMS_free(oaep);
 907         if (maskHash)
 908                 X509_ALGOR_free(maskHash);
 909         return rv;
 910         }
 911
 912 static int rsa_cms_encrypt(CMS_RecipientInfo *ri)
 913         {
 914         const EVP_MD *md, *mgf1md;
 915         RSA_OAEP_PARAMS *oaep = NULL;
 916         ASN1_STRING *os = NULL;
 917         X509_ALGOR *alg;
 918         EVP_PKEY_CTX *pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
 919         int pad_mode = RSA_PKCS1_PADDING, rv = 0, labellen;
 920         unsigned char *label;
 921         CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &alg);
 922         if (pkctx)
 923                 {
 924                 if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
 925                         return 0;
 926                 }
 927         if (pad_mode == RSA_PKCS1_PADDING)
 928                 {
 929                 X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption),
 930                                                         V_ASN1_NULL, 0);
 931                 return 1;
 932                 }
 933         /* Not supported */
 934         if (pad_mode != RSA_PKCS1_OAEP_PADDING)
 935                 return 0;
 936         if (EVP_PKEY_CTX_get_rsa_oaep_md(pkctx, &md) <= 0)
 937                 goto err;
 938         if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
 939                 goto err;
 940         labellen = EVP_PKEY_CTX_get0_rsa_oaep_label(pkctx, &label);
 941         if (labellen < 0)
 942                 goto err;
 943         oaep = RSA_OAEP_PARAMS_new();
 944         if (!oaep)
 945                 goto err;
 946         if (!rsa_md_to_algor(&oaep->hashFunc, md))
 947                 goto err;
 948         if (!rsa_md_to_mgf1(&oaep->maskGenFunc, mgf1md))
 949                 goto err;
 950         if (labellen > 0)
 951                 {
 952                 ASN1_OCTET_STRING *los = ASN1_OCTET_STRING_new();
 953                 oaep->pSourceFunc = X509_ALGOR_new();
 954                 if (!oaep->pSourceFunc)
 955                         goto err;
 956                 if (!los)
 957                         goto err;
 958                 if (!ASN1_OCTET_STRING_set(los, label, labellen))
 959                         {
 960                         ASN1_OCTET_STRING_free(los);
 961                         goto err;
 962                         }
 963                 X509_ALGOR_set0(oaep->pSourceFunc, OBJ_nid2obj(NID_pSpecified),
 964                                                 V_ASN1_OCTET_STRING, los);
 965                 }
 966         /* create string with pss parameter encoding. */
 967         if (!ASN1_item_pack(oaep, ASN1_ITEM_rptr(RSA_OAEP_PARAMS), &os))
 968                 goto err;
 969         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaesOaep), V_ASN1_SEQUENCE, os);
 970         os = NULL;
 971         rv = 1;
 972         err:
 973         if (oaep)
 974                 RSA_OAEP_PARAMS_free(oaep);
 975         if (os)
 976                 ASN1_STRING_free(os);
 977         return rv;
 978         }
 979
 980 const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[] =
 981         {
 982                 {
 983                 EVP_PKEY_RSA,
 984                 EVP_PKEY_RSA,
 985                 ASN1_PKEY_SIGPARAM_NULL,
 986
 987                 "RSA",
 988                 "OpenSSL RSA method",
 989
 990                 rsa_pub_decode,
 991                 rsa_pub_encode,
 992                 rsa_pub_cmp,
 993                 rsa_pub_print,
 994
 995                 rsa_priv_decode,
 996                 rsa_priv_encode,
 997                 rsa_priv_print,
 998
 999                 int_rsa_size,
1000                 rsa_bits,
1001                 rsa_security_bits,
1002
1003                 0,0,0,0,0,0,
1004
1005                 rsa_sig_print,
1006                 int_rsa_free,
1007                 rsa_pkey_ctrl,
1008                 old_rsa_priv_decode,
1009                 old_rsa_priv_encode,
1010                 rsa_item_verify,
1011                 rsa_item_sign
1012                 },
1013
1014                 {
1015                 EVP_PKEY_RSA2,
1016                 EVP_PKEY_RSA,
1017                 ASN1_PKEY_ALIAS
1018                 }
1019         };