crypto/rsa/rsa_ossl.c

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