crypto/rsa/rsa_eay.c

   1 /* crypto/rsa/rsa_eay.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in
  70  *    the documentation and/or other materials provided with the
  71  *    distribution.
  72  *
  73  * 3. All advertising materials mentioning features or use of this
  74  *    software must display the following acknowledgment:
  75  *    "This product includes software developed by the OpenSSL Project
  76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77  *
  78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79  *    endorse or promote products derived from this software without
  80  *    prior written permission. For written permission, please contact
  81  *    openssl-core@openssl.org.
  82  *
  83  * 5. Products derived from this software may not be called "OpenSSL"
  84  *    nor may "OpenSSL" appear in their names without prior written
  85  *    permission of the OpenSSL Project.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 103  * OF THE POSSIBILITY OF SUCH DAMAGE.
 104  * ====================================================================
 105  *
 106  * This product includes cryptographic software written by Eric Young
 107  * (eay@cryptsoft.com).  This product includes software written by Tim
 108  * Hudson (tjh@cryptsoft.com).
 109  *
 110  */
 111
 112 #include <stdio.h>
 113 #include "cryptlib.h"
 114 #include <openssl/bn.h>
 115 #include <openssl/rsa.h>
 116 #include <openssl/rand.h>
 117
 118 #if !defined(RSA_NULL) && !defined(OPENSSL_FIPS)
 119
 120 static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
 121                 unsigned char *to, RSA *rsa,int padding);
 122 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
 123                 unsigned char *to, RSA *rsa,int padding);
 124 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
 125                 unsigned char *to, RSA *rsa,int padding);
 126 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
 127                 unsigned char *to, RSA *rsa,int padding);
 128 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *i, RSA *rsa);
 129 static int RSA_eay_init(RSA *rsa);
 130 static int RSA_eay_finish(RSA *rsa);
 131 static RSA_METHOD rsa_pkcs1_eay_meth={
 132         "Eric Young's PKCS#1 RSA",
 133         RSA_eay_public_encrypt,
 134         RSA_eay_public_decrypt, /* signature verification */
 135         RSA_eay_private_encrypt, /* signing */
 136         RSA_eay_private_decrypt,
 137         RSA_eay_mod_exp,
 138         BN_mod_exp_mont, /* XXX probably we should not use Montgomery if  e == 3 */
 139         RSA_eay_init,
 140         RSA_eay_finish,
 141         0, /* flags */
 142         NULL,
 143         0, /* rsa_sign */
 144         0  /* rsa_verify */
 145         };
 146
 147 const RSA_METHOD *RSA_PKCS1_SSLeay(void)
 148         {
 149         return(&rsa_pkcs1_eay_meth);
 150         }
 151
 152 static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
 153              unsigned char *to, RSA *rsa, int padding)
 154         {
 155         BIGNUM f,ret;
 156         int i,j,k,num=0,r= -1;
 157         unsigned char *buf=NULL;
 158         BN_CTX *ctx=NULL;
 159
 160         if (BN_num_bits(rsa->n) > OPENSSL_RSA_MAX_MODULUS_BITS)
 161                 {
 162                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_MODULUS_TOO_LARGE);
 163                 return -1;
 164                 }
 165
 166         if (BN_ucmp(rsa->n, rsa->e) <= 0)
 167                 {
 168                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_BAD_E_VALUE);
 169                 return -1;
 170                 }
 171
 172         /* for large moduli, enforce exponent limit */
 173         if (BN_num_bits(rsa->n) > OPENSSL_RSA_SMALL_MODULUS_BITS)
 174                 {
 175                 if (BN_num_bits(rsa->e) > OPENSSL_RSA_MAX_PUBEXP_BITS)
 176                         {
 177                         RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_BAD_E_VALUE);
 178                         return -1;
 179                         }
 180                 }
 181
 182         BN_init(&f);
 183         BN_init(&ret);
 184         if ((ctx=BN_CTX_new()) == NULL) goto err;
 185         num=BN_num_bytes(rsa->n);
 186         if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
 187                 {
 188                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,ERR_R_MALLOC_FAILURE);
 189                 goto err;
 190                 }
 191
 192         switch (padding)
 193                 {
 194         case RSA_PKCS1_PADDING:
 195                 i=RSA_padding_add_PKCS1_type_2(buf,num,from,flen);
 196                 break;
 197 #ifndef OPENSSL_NO_SHA
 198         case RSA_PKCS1_OAEP_PADDING:
 199                 i=RSA_padding_add_PKCS1_OAEP(buf,num,from,flen,NULL,0);
 200                 break;
 201 #endif
 202         case RSA_SSLV23_PADDING:
 203                 i=RSA_padding_add_SSLv23(buf,num,from,flen);
 204                 break;
 205         case RSA_NO_PADDING:
 206                 i=RSA_padding_add_none(buf,num,from,flen);
 207                 break;
 208         default:
 209                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
 210                 goto err;
 211                 }
 212         if (i <= 0) goto err;
 213
 214         if (BN_bin2bn(buf,num,&f) == NULL) goto err;
 215
 216         if (BN_ucmp(&f, rsa->n) >= 0)
 217                 {
 218                 /* usually the padding functions would catch this */
 219                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
 220                 goto err;
 221                 }
 222
 223         if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
 224                 {
 225                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n,
 226                                         CRYPTO_LOCK_RSA, rsa->n, ctx))
 227                         goto err;
 228                 }
 229
 230         if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->e,rsa->n,ctx,
 231                 rsa->_method_mod_n)) goto err;
 232
 233         /* put in leading 0 bytes if the number is less than the
 234          * length of the modulus */
 235         j=BN_num_bytes(&ret);
 236         i=BN_bn2bin(&ret,&(to[num-j]));
 237         for (k=0; k<(num-i); k++)
 238                 to[k]=0;
 239
 240         r=num;
 241 err:
 242         if (ctx != NULL) BN_CTX_free(ctx);
 243         BN_clear_free(&f);
 244         BN_clear_free(&ret);
 245         if (buf != NULL)
 246                 {
 247                 OPENSSL_cleanse(buf,num);
 248                 OPENSSL_free(buf);
 249                 }
 250         return(r);
 251         }
 252
 253 static int blinding_helper(RSA *rsa, BN_CTX *ctx)
 254         {
 255         int ret = 0;
 256         int got_write_lock = 0;
 257
 258         CRYPTO_r_lock(CRYPTO_LOCK_RSA);
 259
 260         if (rsa->flags & RSA_FLAG_NO_BLINDING)
 261                 ret = 1;
 262         else
 263                 {
 264                 if (rsa->blinding != NULL)
 265                         ret = 1;
 266                 else
 267                         {
 268                         CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
 269                         CRYPTO_w_lock(CRYPTO_LOCK_RSA);
 270                         got_write_lock = 1;
 271
 272                         if(rsa->blinding != NULL)
 273                                 ret = 1;
 274                         else
 275                                 ret = RSA_blinding_on(rsa, ctx);
 276                         }
 277                 }
 278
 279         if (got_write_lock)
 280                 CRYPTO_w_unlock(CRYPTO_LOCK_RSA);
 281         else
 282                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
 283
 284         return ret;
 285         }
 286
 287 static BN_BLINDING *setup_blinding(RSA *rsa, BN_CTX *ctx)
 288         {
 289         BIGNUM *A, *Ai;
 290         BN_BLINDING *ret = NULL;
 291
 292         /* added in OpenSSL 0.9.6j and 0.9.7b */
 293
 294         /* NB: similar code appears in RSA_blinding_on (rsa_lib.c);
 295          * this should be placed in a new function of its own, but for reasons
 296          * of binary compatibility can't */
 297
 298         BN_CTX_start(ctx);
 299         A = BN_CTX_get(ctx);
 300         if ((RAND_status() == 0) && rsa->d != NULL && rsa->d->d != NULL)
 301                 {
 302                 /* if PRNG is not properly seeded, resort to secret exponent as unpredictable seed */
 303                 RAND_add(rsa->d->d, rsa->d->dmax * sizeof rsa->d->d[0], 0);
 304                 if (!BN_pseudo_rand_range(A,rsa->n)) goto err;
 305                 }
 306         else
 307                 {
 308                 if (!BN_rand_range(A,rsa->n)) goto err;
 309                 }
 310         if ((Ai=BN_mod_inverse(NULL,A,rsa->n,ctx)) == NULL) goto err;
 311
 312         if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
 313                 {
 314                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n,
 315                                         CRYPTO_LOCK_RSA, rsa->n, ctx))
 316                         goto err;
 317                 }
 318
 319         if (!rsa->meth->bn_mod_exp(A,A,rsa->e,rsa->n,ctx,rsa->_method_mod_n))
 320                 goto err;
 321         ret = BN_BLINDING_new(A,Ai,rsa->n);
 322         BN_free(Ai);
 323 err:
 324         BN_CTX_end(ctx);
 325         return ret;
 326         }
 327
 328 /* signing */
 329 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
 330              unsigned char *to, RSA *rsa, int padding)
 331         {
 332         BIGNUM f,ret, *res;
 333         int i,j,k,num=0,r= -1;
 334         unsigned char *buf=NULL;
 335         BN_CTX *ctx=NULL;
 336         int local_blinding = 0;
 337         BN_BLINDING *blinding = NULL;
 338
 339         BN_init(&f);
 340         BN_init(&ret);
 341
 342         if ((ctx=BN_CTX_new()) == NULL) goto err;
 343         num=BN_num_bytes(rsa->n);
 344         if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
 345                 {
 346                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
 347                 goto err;
 348                 }
 349
 350         switch (padding)
 351                 {
 352         case RSA_PKCS1_PADDING:
 353                 i=RSA_padding_add_PKCS1_type_1(buf,num,from,flen);
 354                 break;
 355         case RSA_NO_PADDING:
 356                 i=RSA_padding_add_none(buf,num,from,flen);
 357                 break;
 358         case RSA_SSLV23_PADDING:
 359         default:
 360                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
 361                 goto err;
 362                 }
 363         if (i <= 0) goto err;
 364
 365         if (BN_bin2bn(buf,num,&f) == NULL) goto err;
 366
 367         if (BN_ucmp(&f, rsa->n) >= 0)
 368                 {
 369                 /* usually the padding functions would catch this */
 370                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
 371                 goto err;
 372                 }
 373
 374         if (!blinding_helper(rsa, ctx))
 375                 goto err;
 376         blinding = rsa->blinding;
 377
 378         /* Now unless blinding is disabled, 'blinding' is non-NULL.
 379          * But the BN_BLINDING object may be owned by some other thread
 380          * (we don't want to keep it constant and we don't want to use
 381          * lots of locking to avoid race conditions, so only a single
 382          * thread can use it; other threads have to use local blinding
 383          * factors) */
 384         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
 385                 {
 386                 if (blinding == NULL)
 387                         {
 388                         RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT, ERR_R_INTERNAL_ERROR);
 389                         goto err;
 390                         }
 391                 }
 392
 393         if (blinding != NULL)
 394                 {
 395                 if (1)
 396                         {
 397                         /* we need a local one-time blinding factor */
 398
 399                         blinding = setup_blinding(rsa, ctx);
 400                         if (blinding == NULL)
 401                                 goto err;
 402                         local_blinding = 1;
 403                         }
 404                 }
 405
 406         if (blinding)
 407                 if (!BN_BLINDING_convert(&f, blinding, ctx)) goto err;
 408
 409         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
 410                 ((rsa->p != NULL) &&
 411                 (rsa->q != NULL) &&
 412                 (rsa->dmp1 != NULL) &&
 413                 (rsa->dmq1 != NULL) &&
 414                 (rsa->iqmp != NULL)) )
 415                 {
 416                 if (!rsa->meth->rsa_mod_exp(&ret,&f,rsa)) goto err;
 417                 }
 418         else
 419                 {
 420                 BIGNUM local_d;
 421                 BIGNUM *d = NULL;
 422
 423                 if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
 424                         {
 425                         BN_init(&local_d);
 426                         d = &local_d;
 427                         BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
 428                         }
 429                 else
 430                         d = rsa->d;
 431                 if (!rsa->meth->bn_mod_exp(&ret,&f,d,rsa->n,ctx,NULL)) goto err;
 432                 }
 433
 434         if (blinding)
 435                 if (!BN_BLINDING_invert(&ret, blinding, ctx)) goto err;
 436
 437         if (padding == RSA_X931_PADDING)
 438                 {
 439                 BN_sub(&f, rsa->n, &ret);
 440                 if (BN_cmp(&ret, &f))
 441                         res = &f;
 442                 else
 443                         res = &ret;
 444                 }
 445         else
 446                 res = &ret;
 447
 448         /* put in leading 0 bytes if the number is less than the
 449          * length of the modulus */
 450         j=BN_num_bytes(res);
 451         i=BN_bn2bin(res,&(to[num-j]));
 452         for (k=0; k<(num-i); k++)
 453                 to[k]=0;
 454
 455         r=num;
 456 err:
 457         if (ctx != NULL) BN_CTX_free(ctx);
 458         BN_clear_free(&ret);
 459         BN_clear_free(&f);
 460         if (local_blinding)
 461                 BN_BLINDING_free(blinding);
 462         if (buf != NULL)
 463                 {
 464                 OPENSSL_cleanse(buf,num);
 465                 OPENSSL_free(buf);
 466                 }
 467         return(r);
 468         }
 469
 470 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
 471              unsigned char *to, RSA *rsa, int padding)
 472         {
 473         BIGNUM f,ret;
 474         int j,num=0,r= -1;
 475         unsigned char *p;
 476         unsigned char *buf=NULL;
 477         BN_CTX *ctx=NULL;
 478         int local_blinding = 0;
 479         BN_BLINDING *blinding = NULL;
 480
 481         BN_init(&f);
 482         BN_init(&ret);
 483         ctx=BN_CTX_new();
 484         if (ctx == NULL) goto err;
 485
 486         num=BN_num_bytes(rsa->n);
 487
 488         if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
 489                 {
 490                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
 491                 goto err;
 492                 }
 493
 494         /* This check was for equality but PGP does evil things
 495          * and chops off the top '0' bytes */
 496         if (flen > num)
 497                 {
 498                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
 499                 goto err;
 500                 }
 501
 502         /* make data into a big number */
 503         if (BN_bin2bn(from,(int)flen,&f) == NULL) goto err;
 504
 505         if (BN_ucmp(&f, rsa->n) >= 0)
 506                 {
 507                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
 508                 goto err;
 509                 }
 510
 511         if (!blinding_helper(rsa, ctx))
 512                 goto err;
 513         blinding = rsa->blinding;
 514
 515         /* Now unless blinding is disabled, 'blinding' is non-NULL.
 516          * But the BN_BLINDING object may be owned by some other thread
 517          * (we don't want to keep it constant and we don't want to use
 518          * lots of locking to avoid race conditions, so only a single
 519          * thread can use it; other threads have to use local blinding
 520          * factors) */
 521         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
 522                 {
 523                 if (blinding == NULL)
 524                         {
 525                         RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT, ERR_R_INTERNAL_ERROR);
 526                         goto err;
 527                         }
 528                 }
 529
 530         if (blinding != NULL)
 531                 {
 532                 if (1)
 533                         {
 534                         /* we need a local one-time blinding factor */
 535
 536                         blinding = setup_blinding(rsa, ctx);
 537                         if (blinding == NULL)
 538                                 goto err;
 539                         local_blinding = 1;
 540                         }
 541                 }
 542
 543         if (blinding)
 544                 if (!BN_BLINDING_convert(&f, blinding, ctx)) goto err;
 545
 546         /* do the decrypt */
 547         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
 548                 ((rsa->p != NULL) &&
 549                 (rsa->q != NULL) &&
 550                 (rsa->dmp1 != NULL) &&
 551                 (rsa->dmq1 != NULL) &&
 552                 (rsa->iqmp != NULL)) )
 553                 {
 554                 if (!rsa->meth->rsa_mod_exp(&ret,&f,rsa)) goto err;
 555                 }
 556         else
 557                 {
 558                 BIGNUM local_d;
 559                 BIGNUM *d = NULL;
 560
 561                 if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
 562                         {
 563                         d = &local_d;
 564                         BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
 565                         }
 566                 else
 567                         d = rsa->d;
 568                 if (!rsa->meth->bn_mod_exp(&ret,&f,d,rsa->n,ctx,NULL))
 569                         goto err;
 570                 }
 571
 572         if (blinding)
 573                 if (!BN_BLINDING_invert(&ret, blinding, ctx)) goto err;
 574
 575         p=buf;
 576         j=BN_bn2bin(&ret,p); /* j is only used with no-padding mode */
 577
 578         switch (padding)
 579                 {
 580         case RSA_PKCS1_PADDING:
 581                 r=RSA_padding_check_PKCS1_type_2(to,num,buf,j,num);
 582                 break;
 583 #ifndef OPENSSL_NO_SHA
 584         case RSA_PKCS1_OAEP_PADDING:
 585                 r=RSA_padding_check_PKCS1_OAEP(to,num,buf,j,num,NULL,0);
 586                 break;
 587 #endif
 588         case RSA_SSLV23_PADDING:
 589                 r=RSA_padding_check_SSLv23(to,num,buf,j,num);
 590                 break;
 591         case RSA_NO_PADDING:
 592                 r=RSA_padding_check_none(to,num,buf,j,num);
 593                 break;
 594         default:
 595                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
 596                 goto err;
 597                 }
 598         if (r < 0)
 599                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
 600
 601 err:
 602         if (ctx != NULL) BN_CTX_free(ctx);
 603         BN_clear_free(&f);
 604         BN_clear_free(&ret);
 605         if (local_blinding)
 606                 BN_BLINDING_free(blinding);
 607         if (buf != NULL)
 608                 {
 609                 OPENSSL_cleanse(buf,num);
 610                 OPENSSL_free(buf);
 611                 }
 612         return(r);
 613         }
 614
 615 /* signature verification */
 616 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
 617              unsigned char *to, RSA *rsa, int padding)
 618         {
 619         BIGNUM f,ret;
 620         int i,num=0,r= -1;
 621         unsigned char *p;
 622         unsigned char *buf=NULL;
 623         BN_CTX *ctx=NULL;
 624
 625         if (BN_num_bits(rsa->n) > OPENSSL_RSA_MAX_MODULUS_BITS)
 626                 {
 627                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_MODULUS_TOO_LARGE);
 628                 return -1;
 629                 }
 630
 631         if (BN_ucmp(rsa->n, rsa->e) <= 0)
 632                 {
 633                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_BAD_E_VALUE);
 634                 return -1;
 635                 }
 636
 637         /* for large moduli, enforce exponent limit */
 638         if (BN_num_bits(rsa->n) > OPENSSL_RSA_SMALL_MODULUS_BITS)
 639                 {
 640                 if (BN_num_bits(rsa->e) > OPENSSL_RSA_MAX_PUBEXP_BITS)
 641                         {
 642                         RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_BAD_E_VALUE);
 643                         return -1;
 644                         }
 645                 }
 646
 647         BN_init(&f);
 648         BN_init(&ret);
 649         ctx=BN_CTX_new();
 650         if (ctx == NULL) goto err;
 651
 652         num=BN_num_bytes(rsa->n);
 653         buf=(unsigned char *)OPENSSL_malloc(num);
 654         if (buf == NULL)
 655                 {
 656                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
 657                 goto err;
 658                 }
 659
 660         /* This check was for equality but PGP does evil things
 661          * and chops off the top '0' bytes */
 662         if (flen > num)
 663                 {
 664                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
 665                 goto err;
 666                 }
 667
 668         if (BN_bin2bn(from,flen,&f) == NULL) goto err;
 669
 670         if (BN_ucmp(&f, rsa->n) >= 0)
 671                 {
 672                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
 673                 goto err;
 674                 }
 675
 676         /* do the decrypt */
 677
 678         if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
 679                 {
 680                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n,
 681                                         CRYPTO_LOCK_RSA, rsa->n, ctx))
 682                         goto err;
 683                 }
 684
 685         if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->e,rsa->n,ctx,
 686                 rsa->_method_mod_n)) goto err;
 687
 688         if ((padding == RSA_X931_PADDING) && ((ret.d[0] & 0xf) != 12))
 689                 BN_sub(&ret, rsa->n, &ret);
 690
 691         p=buf;
 692         i=BN_bn2bin(&ret,p);
 693
 694         switch (padding)
 695                 {
 696         case RSA_PKCS1_PADDING:
 697                 r=RSA_padding_check_PKCS1_type_1(to,num,buf,i,num);
 698                 break;
 699         case RSA_NO_PADDING:
 700                 r=RSA_padding_check_none(to,num,buf,i,num);
 701                 break;
 702         default:
 703                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
 704                 goto err;
 705                 }
 706         if (r < 0)
 707                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
 708
 709 err:
 710         if (ctx != NULL) BN_CTX_free(ctx);
 711         BN_clear_free(&f);
 712         BN_clear_free(&ret);
 713         if (buf != NULL)
 714                 {
 715                 OPENSSL_cleanse(buf,num);
 716                 OPENSSL_free(buf);
 717                 }
 718         return(r);
 719         }
 720
 721 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
 722         {
 723         BIGNUM r1,m1,vrfy;
 724         BIGNUM local_dmp1, local_dmq1;
 725         BIGNUM *dmp1, *dmq1;
 726         int ret=0;
 727         BN_CTX *ctx;
 728
 729         BN_init(&m1);
 730         BN_init(&r1);
 731         BN_init(&vrfy);
 732         if ((ctx=BN_CTX_new()) == NULL) goto err;
 733
 734         if (rsa->flags & RSA_FLAG_CACHE_PRIVATE)
 735                 {
 736                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_p,
 737                                         CRYPTO_LOCK_RSA, rsa->p, ctx))
 738                         goto err;
 739                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_q,
 740                                         CRYPTO_LOCK_RSA, rsa->q, ctx))
 741                         goto err;
 742                 }
 743
 744         if (!BN_mod(&r1,I,rsa->q,ctx)) goto err;
 745         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
 746                 {
 747                 dmq1 = &local_dmq1;
 748                 BN_with_flags(dmq1, rsa->dmq1, BN_FLG_EXP_CONSTTIME);
 749                 }
 750         else
 751                 dmq1 = rsa->dmq1;
 752         if (!rsa->meth->bn_mod_exp(&m1,&r1,dmq1,rsa->q,ctx,
 753                 rsa->_method_mod_q)) goto err;
 754
 755         if (!BN_mod(&r1,I,rsa->p,ctx)) goto err;
 756         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
 757                 {
 758                 dmp1 = &local_dmp1;
 759                 BN_with_flags(dmp1, rsa->dmp1, BN_FLG_EXP_CONSTTIME);
 760                 }
 761         else
 762                 dmp1 = rsa->dmp1;
 763         if (!rsa->meth->bn_mod_exp(r0,&r1,dmp1,rsa->p,ctx,
 764                 rsa->_method_mod_p)) goto err;
 765
 766         if (!BN_sub(r0,r0,&m1)) goto err;
 767         /* This will help stop the size of r0 increasing, which does
 768          * affect the multiply if it optimised for a power of 2 size */
 769         if (r0->neg)
 770                 if (!BN_add(r0,r0,rsa->p)) goto err;
 771
 772         if (!BN_mul(&r1,r0,rsa->iqmp,ctx)) goto err;
 773         if (!BN_mod(r0,&r1,rsa->p,ctx)) goto err;
 774         /* If p < q it is occasionally possible for the correction of
 775          * adding 'p' if r0 is negative above to leave the result still
 776          * negative. This can break the private key operations: the following
 777          * second correction should *always* correct this rare occurrence.
 778          * This will *never* happen with OpenSSL generated keys because
 779          * they ensure p > q [steve]
 780          */
 781         if (r0->neg)
 782                 if (!BN_add(r0,r0,rsa->p)) goto err;
 783         if (!BN_mul(&r1,r0,rsa->q,ctx)) goto err;
 784         if (!BN_add(r0,&r1,&m1)) goto err;
 785
 786         if (rsa->e && rsa->n)
 787                 {
 788                 if (!rsa->meth->bn_mod_exp(&vrfy,r0,rsa->e,rsa->n,ctx,NULL)) goto err;
 789                 /* If 'I' was greater than (or equal to) rsa->n, the operation
 790                  * will be equivalent to using 'I mod n'. However, the result of
 791                  * the verify will *always* be less than 'n' so we don't check
 792                  * for absolute equality, just congruency. */
 793                 if (!BN_sub(&vrfy, &vrfy, I)) goto err;
 794                 if (!BN_mod(&vrfy, &vrfy, rsa->n, ctx)) goto err;
 795                 if (vrfy.neg)
 796                         if (!BN_add(&vrfy, &vrfy, rsa->n)) goto err;
 797                 if (!BN_is_zero(&vrfy))
 798                         {
 799                         /* 'I' and 'vrfy' aren't congruent mod n. Don't leak
 800                          * miscalculated CRT output, just do a raw (slower)
 801                          * mod_exp and return that instead. */
 802
 803                         BIGNUM local_d;
 804                         BIGNUM *d = NULL;
 805
 806                         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
 807                                 {
 808                                 d = &local_d;
 809                                 BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
 810                                 }
 811                         else
 812                                 d = rsa->d;
 813                         if (!rsa->meth->bn_mod_exp(r0,I,d,rsa->n,ctx,NULL)) goto err;
 814                         }
 815                 }
 816         ret=1;
 817 err:
 818         BN_clear_free(&m1);
 819         BN_clear_free(&r1);
 820         BN_clear_free(&vrfy);
 821         BN_CTX_free(ctx);
 822         return(ret);
 823         }
 824
 825 static int RSA_eay_init(RSA *rsa)
 826         {
 827         rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
 828         return(1);
 829         }
 830
 831 static int RSA_eay_finish(RSA *rsa)
 832         {
 833         if (rsa->_method_mod_n != NULL)
 834                 BN_MONT_CTX_free(rsa->_method_mod_n);
 835         if (rsa->_method_mod_p != NULL)
 836                 BN_MONT_CTX_free(rsa->_method_mod_p);
 837         if (rsa->_method_mod_q != NULL)
 838                 BN_MONT_CTX_free(rsa->_method_mod_q);
 839         return(1);
 840         }
 841
 842 #endif