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 void int_rsa_free(EVP_PKEY *pkey)
 174         {
 175         RSA_free(pkey->pkey.rsa);
 176         }
 177
 178
 179 static void update_buflen(const BIGNUM *b, size_t *pbuflen)
 180         {
 181         size_t i;
 182         if (!b)
 183                 return;
 184         if (*pbuflen < (i = (size_t)BN_num_bytes(b)))
 185                         *pbuflen = i;
 186         }
 187
 188 static int do_rsa_print(BIO *bp, const RSA *x, int off, int priv)
 189         {
 190         char *str;
 191         const char *s;
 192         unsigned char *m=NULL;
 193         int ret=0, mod_len = 0;
 194         size_t buf_len=0;
 195
 196         update_buflen(x->n, &buf_len);
 197         update_buflen(x->e, &buf_len);
 198
 199         if (priv)
 200                 {
 201                 update_buflen(x->d, &buf_len);
 202                 update_buflen(x->p, &buf_len);
 203                 update_buflen(x->q, &buf_len);
 204                 update_buflen(x->dmp1, &buf_len);
 205                 update_buflen(x->dmq1, &buf_len);
 206                 update_buflen(x->iqmp, &buf_len);
 207                 }
 208
 209         m=(unsigned char *)OPENSSL_malloc(buf_len+10);
 210         if (m == NULL)
 211                 {
 212                 RSAerr(RSA_F_DO_RSA_PRINT,ERR_R_MALLOC_FAILURE);
 213                 goto err;
 214                 }
 215
 216         if (x->n != NULL)
 217                 mod_len = BN_num_bits(x->n);
 218
 219         if(!BIO_indent(bp,off,128))
 220                 goto err;
 221
 222         if (priv && x->d)
 223                 {
 224                 if (BIO_printf(bp,"Private-Key: (%d bit)\n", mod_len)
 225                         <= 0) goto err;
 226                 str = "modulus:";
 227                 s = "publicExponent:";
 228                 }
 229         else
 230                 {
 231                 if (BIO_printf(bp,"Public-Key: (%d bit)\n", mod_len)
 232                         <= 0) goto err;
 233                 str = "Modulus:";
 234                 s= "Exponent:";
 235                 }
 236         if (!ASN1_bn_print(bp,str,x->n,m,off)) goto err;
 237         if (!ASN1_bn_print(bp,s,x->e,m,off))
 238                 goto err;
 239         if (priv)
 240                 {
 241                 if (!ASN1_bn_print(bp,"privateExponent:",x->d,m,off))
 242                         goto err;
 243                 if (!ASN1_bn_print(bp,"prime1:",x->p,m,off))
 244                         goto err;
 245                 if (!ASN1_bn_print(bp,"prime2:",x->q,m,off))
 246                         goto err;
 247                 if (!ASN1_bn_print(bp,"exponent1:",x->dmp1,m,off))
 248                         goto err;
 249                 if (!ASN1_bn_print(bp,"exponent2:",x->dmq1,m,off))
 250                         goto err;
 251                 if (!ASN1_bn_print(bp,"coefficient:",x->iqmp,m,off))
 252                         goto err;
 253                 }
 254         ret=1;
 255 err:
 256         if (m != NULL) OPENSSL_free(m);
 257         return(ret);
 258         }
 259
 260 static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
 261                                                         ASN1_PCTX *ctx)
 262         {
 263         return do_rsa_print(bp, pkey->pkey.rsa, indent, 0);
 264         }
 265
 266
 267 static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
 268                                                         ASN1_PCTX *ctx)
 269         {
 270         return do_rsa_print(bp, pkey->pkey.rsa, indent, 1);
 271         }
 272
 273 /* Given an MGF1 Algorithm ID decode to an Algorithm Identifier */
 274 static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
 275         {
 276         const unsigned char *p;
 277         int plen;
 278         if (alg == NULL)
 279                 return NULL;
 280         if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
 281                 return NULL;
 282         if (alg->parameter->type != V_ASN1_SEQUENCE)
 283                 return NULL;
 284
 285         p = alg->parameter->value.sequence->data;
 286         plen = alg->parameter->value.sequence->length;
 287         return d2i_X509_ALGOR(NULL, &p, plen);
 288         }
 289
 290 static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
 291                                         X509_ALGOR **pmaskHash)
 292         {
 293         const unsigned char *p;
 294         int plen;
 295         RSA_PSS_PARAMS *pss;
 296
 297         *pmaskHash = NULL;
 298
 299         if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
 300                 return NULL;
 301         p = alg->parameter->value.sequence->data;
 302         plen = alg->parameter->value.sequence->length;
 303         pss = d2i_RSA_PSS_PARAMS(NULL, &p, plen);
 304
 305         if (!pss)
 306                 return NULL;
 307
 308         *pmaskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
 309
 310         return pss;
 311         }
 312
 313 static int rsa_pss_param_print(BIO *bp, RSA_PSS_PARAMS *pss,
 314                                 X509_ALGOR *maskHash, int indent)
 315         {
 316         int rv = 0;
 317         if (!pss)
 318                 {
 319                 if (BIO_puts(bp, " (INVALID PSS PARAMETERS)\n") <= 0)
 320                         return 0;
 321                 return 1;
 322                 }
 323         if (BIO_puts(bp, "\n") <= 0)
 324                 goto err;
 325         if (!BIO_indent(bp, indent, 128))
 326                 goto err;
 327         if (BIO_puts(bp, "Hash Algorithm: ") <= 0)
 328                 goto err;
 329
 330         if (pss->hashAlgorithm)
 331                 {
 332                 if (i2a_ASN1_OBJECT(bp, pss->hashAlgorithm->algorithm) <= 0)
 333                         goto err;
 334                 }
 335         else if (BIO_puts(bp, "sha1 (default)") <= 0)
 336                 goto err;
 337
 338         if (BIO_puts(bp, "\n") <= 0)
 339                 goto err;
 340
 341         if (!BIO_indent(bp, indent, 128))
 342                 goto err;
 343
 344         if (BIO_puts(bp, "Mask Algorithm: ") <= 0)
 345                         goto err;
 346         if (pss->maskGenAlgorithm)
 347                 {
 348                 if (i2a_ASN1_OBJECT(bp, pss->maskGenAlgorithm->algorithm) <= 0)
 349                         goto err;
 350                 if (BIO_puts(bp, " with ") <= 0)
 351                         goto err;
 352                 if (maskHash)
 353                         {
 354                         if (i2a_ASN1_OBJECT(bp, maskHash->algorithm) <= 0)
 355                         goto err;
 356                         }
 357                 else if (BIO_puts(bp, "INVALID") <= 0)
 358                         goto err;
 359                 }
 360         else if (BIO_puts(bp, "mgf1 with sha1 (default)") <= 0)
 361                 goto err;
 362         BIO_puts(bp, "\n");
 363
 364         if (!BIO_indent(bp, indent, 128))
 365                 goto err;
 366         if (BIO_puts(bp, "Salt Length: 0x") <= 0)
 367                         goto err;
 368         if (pss->saltLength)
 369                 {
 370                 if (i2a_ASN1_INTEGER(bp, pss->saltLength) <= 0)
 371                         goto err;
 372                 }
 373         else if (BIO_puts(bp, "0x14 (default)") <= 0)
 374                 goto err;
 375         BIO_puts(bp, "\n");
 376
 377         if (!BIO_indent(bp, indent, 128))
 378                 goto err;
 379         if (BIO_puts(bp, "Trailer Field: 0x") <= 0)
 380                         goto err;
 381         if (pss->trailerField)
 382                 {
 383                 if (i2a_ASN1_INTEGER(bp, pss->trailerField) <= 0)
 384                         goto err;
 385                 }
 386         else if (BIO_puts(bp, "BC (default)") <= 0)
 387                 goto err;
 388         BIO_puts(bp, "\n");
 389
 390         rv = 1;
 391
 392         err:
 393         return rv;
 394
 395         }
 396
 397 static int rsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
 398                                         const ASN1_STRING *sig,
 399                                         int indent, ASN1_PCTX *pctx)
 400         {
 401         if (OBJ_obj2nid(sigalg->algorithm) == NID_rsassaPss)
 402                 {
 403                 int rv;
 404                 RSA_PSS_PARAMS *pss;
 405                 X509_ALGOR *maskHash;
 406                 pss = rsa_pss_decode(sigalg, &maskHash);
 407                 rv = rsa_pss_param_print(bp, pss, maskHash, indent);
 408                 if (pss)
 409                         RSA_PSS_PARAMS_free(pss);
 410                 if (maskHash)
 411                         X509_ALGOR_free(maskHash);
 412                 if (!rv)
 413                         return 0;
 414                 }
 415         else if (!sig && BIO_puts(bp, "\n") <= 0)
 416                 return 0;
 417         if (sig)
 418                 return X509_signature_dump(bp, sig, indent);
 419         return 1;
 420         }
 421
 422 static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
 423         {
 424         X509_ALGOR *alg = NULL;
 425         switch (op)
 426                 {
 427
 428                 case ASN1_PKEY_CTRL_PKCS7_SIGN:
 429                 if (arg1 == 0)
 430                         PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
 431                 break;
 432
 433                 case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
 434                 if (arg1 == 0)
 435                         PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
 436                 break;
 437 #ifndef OPENSSL_NO_CMS
 438                 case ASN1_PKEY_CTRL_CMS_SIGN:
 439                 if (arg1 == 0)
 440                         return rsa_cms_sign(arg2);
 441                 else if (arg1 == 1)
 442                         return rsa_cms_verify(arg2);
 443                 break;
 444
 445                 case ASN1_PKEY_CTRL_CMS_ENVELOPE:
 446                 if (arg1 == 0)
 447                         return rsa_cms_encrypt(arg2);
 448                 else if (arg1 == 1)
 449                         return rsa_cms_decrypt(arg2);
 450                 break;
 451
 452                 case ASN1_PKEY_CTRL_CMS_RI_TYPE:
 453                 *(int *)arg2 = CMS_RECIPINFO_TRANS;
 454                 return 1;
 455 #endif
 456
 457                 case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
 458                 *(int *)arg2 = NID_sha1;
 459                 return 1;
 460
 461                 default:
 462                 return -2;
 463
 464                 }
 465
 466         if (alg)
 467                 X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption),
 468                                                         V_ASN1_NULL, 0);
 469
 470         return 1;
 471
 472         }
 473
 474 /* allocate and set algorithm ID from EVP_MD, default SHA1 */
 475 static int rsa_md_to_algor(X509_ALGOR **palg, const EVP_MD *md)
 476         {
 477         if (EVP_MD_type(md) == NID_sha1)
 478                 return 1;
 479         *palg = X509_ALGOR_new();
 480         if (!*palg)
 481                 return 0;
 482         X509_ALGOR_set_md(*palg, md);
 483         return 1;
 484         }
 485
 486 /* Allocate and set MGF1 algorithm ID from EVP_MD */
 487 static int rsa_md_to_mgf1(X509_ALGOR **palg, const EVP_MD *mgf1md)
 488         {
 489         X509_ALGOR *algtmp = NULL;
 490         ASN1_STRING *stmp = NULL;
 491         *palg = NULL;
 492         if (EVP_MD_type(mgf1md) == NID_sha1)
 493                 return 1;
 494         /* need to embed algorithm ID inside another */
 495         if (!rsa_md_to_algor(&algtmp, mgf1md))
 496                 goto err;
 497         if (!ASN1_item_pack(algtmp, ASN1_ITEM_rptr(X509_ALGOR), &stmp))
 498                         goto err;
 499         *palg = X509_ALGOR_new();
 500         if (!*palg)
 501                 goto err;
 502         X509_ALGOR_set0(*palg, OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
 503         stmp = NULL;
 504         err:
 505         if (stmp)
 506                 ASN1_STRING_free(stmp);
 507         if (algtmp)
 508                 X509_ALGOR_free(algtmp);
 509         if (*palg)
 510                 return 1;
 511         return 0;
 512         }
 513
 514 /* convert algorithm ID to EVP_MD, default SHA1 */
 515 static const EVP_MD *rsa_algor_to_md(X509_ALGOR *alg)
 516         {
 517         const EVP_MD *md;
 518         if (!alg)
 519                 return EVP_sha1();
 520         md = EVP_get_digestbyobj(alg->algorithm);
 521         if (md == NULL)
 522                 RSAerr(RSA_F_RSA_ALGOR_TO_MD, RSA_R_UNKNOWN_DIGEST);
 523         return md;
 524         }
 525 /* convert MGF1 algorithm ID to EVP_MD, default SHA1 */
 526 static const EVP_MD *rsa_mgf1_to_md(X509_ALGOR *alg, X509_ALGOR *maskHash)
 527         {
 528         const EVP_MD *md;
 529         if (!alg)
 530                 return EVP_sha1();
 531         /* Check mask and lookup mask hash algorithm */
 532         if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
 533                 {
 534                 RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_ALGORITHM);
 535                 return NULL;
 536                 }
 537         if (!maskHash)
 538                 {
 539                 RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_PARAMETER);
 540                 return NULL;
 541                 }
 542         md = EVP_get_digestbyobj(maskHash->algorithm);
 543         if (md == NULL)
 544                 {
 545                 RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNKNOWN_MASK_DIGEST);
 546                 return NULL;
 547                 }
 548         return md;
 549         }
 550
 551 /* Convert EVP_PKEY_CTX is PSS mode into corresponding algorithm parameter,
 552  * suitable for setting an AlgorithmIdentifier.
 553  */
 554
 555 static ASN1_STRING *rsa_ctx_to_pss(EVP_PKEY_CTX *pkctx)
 556         {
 557         const EVP_MD *sigmd, *mgf1md;
 558         RSA_PSS_PARAMS *pss = NULL;
 559         ASN1_STRING *os = NULL;
 560         EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(pkctx);
 561         int saltlen, rv = 0;
 562         if (EVP_PKEY_CTX_get_signature_md(pkctx, &sigmd) <= 0)
 563                 goto err;
 564         if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
 565                 goto err;
 566         if (!EVP_PKEY_CTX_get_rsa_pss_saltlen(pkctx, &saltlen))
 567                 goto err;
 568         if (saltlen == -1)
 569                 saltlen = EVP_MD_size(sigmd);
 570         else if (saltlen == -2)
 571                 {
 572                 saltlen = EVP_PKEY_size(pk) - EVP_MD_size(sigmd) - 2;
 573                 if (((EVP_PKEY_bits(pk) - 1) & 0x7) == 0)
 574                         saltlen--;
 575                 }
 576         pss = RSA_PSS_PARAMS_new();
 577         if (!pss)
 578                 goto err;
 579         if (saltlen != 20)
 580                 {
 581                 pss->saltLength = ASN1_INTEGER_new();
 582                 if (!pss->saltLength)
 583                         goto err;
 584                 if (!ASN1_INTEGER_set(pss->saltLength, saltlen))
 585                         goto err;
 586                 }
 587         if (!rsa_md_to_algor(&pss->hashAlgorithm, sigmd))
 588                 goto err;
 589         if (!rsa_md_to_mgf1(&pss->maskGenAlgorithm, mgf1md))
 590                 goto err;
 591         /* Finally create string with pss parameter encoding. */
 592         if (!ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), &os))
 593                 goto err;
 594         rv = 1;
 595         err:
 596         if (pss)
 597                 RSA_PSS_PARAMS_free(pss);
 598         if (rv)
 599                 return os;
 600         if (os)
 601                 ASN1_STRING_free(os);
 602         return NULL;
 603         }
 604
 605 /* From PSS AlgorithmIdentifier set public key parameters. If pkey
 606  * isn't NULL then the EVP_MD_CTX is setup and initalised. If it
 607  * is NULL parameters are passed to pkctx instead.
 608  */
 609
 610 static int rsa_pss_to_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pkctx,
 611                                 X509_ALGOR *sigalg, EVP_PKEY *pkey)
 612         {
 613         int rv = -1;
 614         int saltlen;
 615         const EVP_MD *mgf1md = NULL, *md = NULL;
 616         RSA_PSS_PARAMS *pss;
 617         X509_ALGOR *maskHash;
 618         /* Sanity check: make sure it is PSS */
 619         if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss)
 620                 {
 621                 RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
 622                 return -1;
 623                 }
 624         /* Decode PSS parameters */
 625         pss = rsa_pss_decode(sigalg, &maskHash);
 626
 627         if (pss == NULL)
 628                 {
 629                 RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_PSS_PARAMETERS);
 630                 goto err;
 631                 }
 632         mgf1md = rsa_mgf1_to_md(pss->maskGenAlgorithm, maskHash);
 633         if (!mgf1md)
 634                 goto err;
 635         md = rsa_algor_to_md(pss->hashAlgorithm);
 636         if (!md)
 637                 goto err;
 638
 639         if (pss->saltLength)
 640                 {
 641                 saltlen = ASN1_INTEGER_get(pss->saltLength);
 642
 643                 /* Could perform more salt length sanity checks but the main
 644                  * RSA routines will trap other invalid values anyway.
 645                  */
 646                 if (saltlen < 0)
 647                         {
 648                         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_SALT_LENGTH);
 649                         goto err;
 650                         }
 651                 }
 652         else
 653                 saltlen = 20;
 654
 655         /* low-level routines support only trailer field 0xbc (value 1)
 656          * and PKCS#1 says we should reject any other value anyway.
 657          */
 658         if (pss->trailerField && ASN1_INTEGER_get(pss->trailerField) != 1)
 659                 {
 660                 RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_TRAILER);
 661                 goto err;
 662                 }
 663
 664         /* We have all parameters now set up context */
 665
 666         if (pkey)
 667                 {
 668                 if (!EVP_DigestVerifyInit(ctx, &pkctx, md, NULL, pkey))
 669                         goto err;
 670                 }
 671         else
 672                 {
 673                 const EVP_MD *checkmd;
 674                 if (EVP_PKEY_CTX_get_signature_md(pkctx, &checkmd) <= 0)
 675                         goto err;
 676                 if (EVP_MD_type(md) != EVP_MD_type(checkmd))
 677                         {
 678                         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_DIGEST_DOES_NOT_MATCH);
 679                         goto err;
 680                         }
 681                 }
 682
 683         if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_PSS_PADDING) <= 0)
 684                 goto err;
 685
 686         if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkctx, saltlen) <= 0)
 687                 goto err;
 688
 689         if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
 690                 goto err;
 691         /* Carry on */
 692         rv = 1;
 693
 694         err:
 695         RSA_PSS_PARAMS_free(pss);
 696         if (maskHash)
 697                 X509_ALGOR_free(maskHash);
 698         return rv;
 699         }
 700
 701 static int rsa_cms_verify(CMS_SignerInfo *si)
 702         {
 703         int nid, nid2;
 704         X509_ALGOR *alg;
 705         EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
 706         CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
 707         nid = OBJ_obj2nid(alg->algorithm);
 708         if (nid == NID_rsaEncryption)
 709                 return 1;
 710         if (nid == NID_rsassaPss)
 711                 return rsa_pss_to_ctx(NULL, pkctx, alg, NULL);
 712         /* Workaround for some implementation that use a signature OID */
 713         if (OBJ_find_sigid_algs(nid, NULL, &nid2))
 714                 {
 715                 if (nid2 == NID_rsaEncryption)
 716                         return 1;
 717                 }
 718         return 0;
 719         }
 720
 721 /* Customised RSA item verification routine. This is called
 722  * when a signature is encountered requiring special handling. We
 723  * currently only handle PSS.
 724  */
 725
 726
 727 static int rsa_item_verify(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
 728                         X509_ALGOR *sigalg, ASN1_BIT_STRING *sig,
 729                         EVP_PKEY *pkey)
 730         {
 731         /* Sanity check: make sure it is PSS */
 732         if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss)
 733                 {
 734                 RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
 735                 return -1;
 736                 }
 737         if (rsa_pss_to_ctx(ctx, NULL, sigalg, pkey))
 738                 /* Carry on */
 739                 return 2;
 740         return -1;
 741         }
 742
 743 static int rsa_cms_sign(CMS_SignerInfo *si)
 744         {
 745         int pad_mode = RSA_PKCS1_PADDING;
 746         X509_ALGOR *alg;
 747         EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
 748         ASN1_STRING *os = NULL;
 749         CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
 750         if (pkctx)
 751                 {
 752                 if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
 753                         return 0;
 754                 }
 755         if (pad_mode == RSA_PKCS1_PADDING)
 756                 {
 757                 X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption),
 758                                                         V_ASN1_NULL, 0);
 759                 return 1;
 760                 }
 761         /* We don't support it */
 762         if (pad_mode != RSA_PKCS1_PSS_PADDING)
 763                 return 0;
 764         os = rsa_ctx_to_pss(pkctx);
 765         if (!os)
 766                 return 0;
 767         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsassaPss), V_ASN1_SEQUENCE, os);
 768         return 1;
 769         }
 770
 771 static int rsa_item_sign(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
 772                                 X509_ALGOR *alg1, X509_ALGOR *alg2,
 773                                 ASN1_BIT_STRING *sig)
 774         {
 775         int pad_mode;
 776         EVP_PKEY_CTX *pkctx = ctx->pctx;
 777         if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
 778                 return 0;
 779         if (pad_mode == RSA_PKCS1_PADDING)
 780                 return 2;
 781         if (pad_mode == RSA_PKCS1_PSS_PADDING)
 782                 {
 783                 ASN1_STRING *os1 = NULL;
 784                 os1 = rsa_ctx_to_pss(pkctx);
 785                 if (!os1)
 786                         return 0;
 787                 /* Duplicate parameters if we have to */
 788                 if (alg2)
 789                         {
 790                         ASN1_STRING *os2 = ASN1_STRING_dup(os1);
 791                         if (!os2)
 792                                 {
 793                                 ASN1_STRING_free(os1);
 794                                 return 0;
 795                                 }
 796                         X509_ALGOR_set0(alg2, OBJ_nid2obj(NID_rsassaPss),
 797                                                 V_ASN1_SEQUENCE, os2);
 798                         }
 799                 X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_rsassaPss),
 800                                         V_ASN1_SEQUENCE, os1);
 801                 return 3;
 802                 }
 803         return 2;
 804         }
 805
 806 static RSA_OAEP_PARAMS *rsa_oaep_decode(const X509_ALGOR *alg,
 807                                         X509_ALGOR **pmaskHash)
 808         {
 809         const unsigned char *p;
 810         int plen;
 811         RSA_OAEP_PARAMS *pss;
 812
 813         *pmaskHash = NULL;
 814
 815         if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
 816                 return NULL;
 817         p = alg->parameter->value.sequence->data;
 818         plen = alg->parameter->value.sequence->length;
 819         pss = d2i_RSA_OAEP_PARAMS(NULL, &p, plen);
 820
 821         if (!pss)
 822                 return NULL;
 823
 824         *pmaskHash = rsa_mgf1_decode(pss->maskGenFunc);
 825
 826         return pss;
 827         }
 828
 829 static int rsa_cms_decrypt(CMS_RecipientInfo *ri)
 830         {
 831         EVP_PKEY_CTX *pkctx;
 832         X509_ALGOR *cmsalg;
 833         int nid;
 834         int rv = -1;
 835         unsigned char *label = NULL;
 836         int labellen = 0;
 837         const EVP_MD *mgf1md = NULL, *md = NULL;
 838         RSA_OAEP_PARAMS *oaep;
 839         X509_ALGOR *maskHash;
 840         pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
 841         if (!pkctx)
 842                 return 0;
 843         if (!CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &cmsalg))
 844                 return -1;
 845         nid = OBJ_obj2nid(cmsalg->algorithm);
 846         if (nid == NID_rsaEncryption)
 847                 return 1;
 848         if (nid != NID_rsaesOaep)
 849                 {
 850                 RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_ENCRYPTION_TYPE);
 851                 return -1;
 852                 }
 853         /* Decode OAEP parameters */
 854         oaep = rsa_oaep_decode(cmsalg, &maskHash);
 855
 856         if (oaep == NULL)
 857                 {
 858                 RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_OAEP_PARAMETERS);
 859                 goto err;
 860                 }
 861
 862         mgf1md = rsa_mgf1_to_md(oaep->maskGenFunc, maskHash);
 863         if (!mgf1md)
 864                 goto err;
 865         md = rsa_algor_to_md(oaep->hashFunc);
 866         if (!md)
 867                 goto err;
 868
 869         if (oaep->pSourceFunc)
 870                 {
 871                 X509_ALGOR *plab = oaep->pSourceFunc;
 872                 if (OBJ_obj2nid(plab->algorithm) != NID_pSpecified)
 873                         {
 874                         RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_LABEL_SOURCE);
 875                         goto err;
 876                         }
 877                 if (plab->parameter->type != V_ASN1_OCTET_STRING)
 878                         {
 879                         RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_LABEL);
 880                         goto err;
 881                         }
 882
 883                 label = plab->parameter->value.octet_string->data;
 884                 /* Stop label being freed when OAEP parameters are freed */
 885                 plab->parameter->value.octet_string->data = NULL;
 886                 labellen = plab->parameter->value.octet_string->length;
 887                 }
 888
 889         if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_OAEP_PADDING) <= 0)
 890                 goto err;
 891         if (EVP_PKEY_CTX_set_rsa_oaep_md(pkctx, md) <= 0)
 892                 goto err;
 893         if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
 894                 goto err;
 895         if (EVP_PKEY_CTX_set0_rsa_oaep_label(pkctx, label, labellen) <= 0)
 896                 goto err;
 897         /* Carry on */
 898         rv = 1;
 899
 900         err:
 901         RSA_OAEP_PARAMS_free(oaep);
 902         if (maskHash)
 903                 X509_ALGOR_free(maskHash);
 904         return rv;
 905         }
 906
 907 static int rsa_cms_encrypt(CMS_RecipientInfo *ri)
 908         {
 909         const EVP_MD *md, *mgf1md;
 910         RSA_OAEP_PARAMS *oaep = NULL;
 911         ASN1_STRING *os = NULL;
 912         X509_ALGOR *alg;
 913         EVP_PKEY_CTX *pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
 914         int pad_mode = RSA_PKCS1_PADDING, rv = 0, labellen;
 915         unsigned char *label;
 916         CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &alg);
 917         if (pkctx)
 918                 {
 919                 if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
 920                         return 0;
 921                 }
 922         if (pad_mode == RSA_PKCS1_PADDING)
 923                 {
 924                 X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption),
 925                                                         V_ASN1_NULL, 0);
 926                 return 1;
 927                 }
 928         /* Not supported */
 929         if (pad_mode != RSA_PKCS1_OAEP_PADDING)
 930                 return 0;
 931         if (EVP_PKEY_CTX_get_rsa_oaep_md(pkctx, &md) <= 0)
 932                 goto err;
 933         if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
 934                 goto err;
 935         labellen = EVP_PKEY_CTX_get0_rsa_oaep_label(pkctx, &label);
 936         if (labellen < 0)
 937                 goto err;
 938         oaep = RSA_OAEP_PARAMS_new();
 939         if (!oaep)
 940                 goto err;
 941         if (!rsa_md_to_algor(&oaep->hashFunc, md))
 942                 goto err;
 943         if (!rsa_md_to_mgf1(&oaep->maskGenFunc, mgf1md))
 944                 goto err;
 945         if (labellen > 0)
 946                 {
 947                 ASN1_OCTET_STRING *los = ASN1_OCTET_STRING_new();
 948                 oaep->pSourceFunc = X509_ALGOR_new();
 949                 if (!oaep->pSourceFunc)
 950                         goto err;
 951                 if (!los)
 952                         goto err;
 953                 if (!ASN1_OCTET_STRING_set(los, label, labellen))
 954                         {
 955                         ASN1_OCTET_STRING_free(los);
 956                         goto err;
 957                         }
 958                 X509_ALGOR_set0(oaep->pSourceFunc, OBJ_nid2obj(NID_pSpecified),
 959                                                 V_ASN1_OCTET_STRING, los);
 960                 }
 961         /* create string with pss parameter encoding. */
 962         if (!ASN1_item_pack(oaep, ASN1_ITEM_rptr(RSA_OAEP_PARAMS), &os))
 963                 goto err;
 964         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaesOaep), V_ASN1_SEQUENCE, os);
 965         os = NULL;
 966         rv = 1;
 967         err:
 968         if (oaep)
 969                 RSA_OAEP_PARAMS_free(oaep);
 970         if (os)
 971                 ASN1_STRING_free(os);
 972         return rv;
 973         }
 974
 975 const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[] =
 976         {
 977                 {
 978                 EVP_PKEY_RSA,
 979                 EVP_PKEY_RSA,
 980                 ASN1_PKEY_SIGPARAM_NULL,
 981
 982                 "RSA",
 983                 "OpenSSL RSA method",
 984
 985                 rsa_pub_decode,
 986                 rsa_pub_encode,
 987                 rsa_pub_cmp,
 988                 rsa_pub_print,
 989
 990                 rsa_priv_decode,
 991                 rsa_priv_encode,
 992                 rsa_priv_print,
 993
 994                 int_rsa_size,
 995                 rsa_bits,
 996
 997                 0,0,0,0,0,0,
 998
 999                 rsa_sig_print,
1000                 int_rsa_free,
1001                 rsa_pkey_ctrl,
1002                 old_rsa_priv_decode,
1003                 old_rsa_priv_encode,
1004                 rsa_item_verify,
1005                 rsa_item_sign
1006                 },
1007
1008                 {
1009                 EVP_PKEY_RSA2,
1010                 EVP_PKEY_RSA,
1011                 ASN1_PKEY_ALIAS
1012                 }
1013         };