1f18854f065789e0e624aecf97e0c55a69a8fa22
[openssl.git] / 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 #define OPENSSL_FIPSEVP
113
114 #include <stdio.h>
115 #include "cryptlib.h"
116 #include <openssl/bn.h>
117 #include <openssl/rsa.h>
118 #include <openssl/rand.h>
119 #ifdef OPENSSL_FIPS
120 #include <openssl/fips.h>
121 #endif
122
123 #ifndef RSA_NULL
124
125 static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
126                 unsigned char *to, RSA *rsa,int padding);
127 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
128                 unsigned char *to, RSA *rsa,int padding);
129 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
130                 unsigned char *to, RSA *rsa,int padding);
131 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
132                 unsigned char *to, RSA *rsa,int padding);
133 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *i, RSA *rsa, BN_CTX *ctx);
134 static int RSA_eay_init(RSA *rsa);
135 static int RSA_eay_finish(RSA *rsa);
136 static RSA_METHOD rsa_pkcs1_eay_meth={
137         "Eric Young's PKCS#1 RSA",
138         RSA_eay_public_encrypt,
139         RSA_eay_public_decrypt, /* signature verification */
140         RSA_eay_private_encrypt, /* signing */
141         RSA_eay_private_decrypt,
142         RSA_eay_mod_exp,
143         BN_mod_exp_mont, /* XXX probably we should not use Montgomery if  e == 3 */
144         RSA_eay_init,
145         RSA_eay_finish,
146         RSA_FLAG_FIPS_METHOD, /* flags */
147         NULL,
148         0, /* rsa_sign */
149         0, /* rsa_verify */
150         NULL /* rsa_keygen */
151         };
152
153 const RSA_METHOD *RSA_PKCS1_SSLeay(void)
154         {
155         return(&rsa_pkcs1_eay_meth);
156         }
157
158 static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
159              unsigned char *to, RSA *rsa, int padding)
160         {
161         BIGNUM *f,*ret;
162         int i,j,k,num=0,r= -1;
163         unsigned char *buf=NULL;
164         BN_CTX *ctx=NULL;
165
166 #ifdef OPENSSL_FIPS
167         if(FIPS_selftest_failed())
168                 {
169                 FIPSerr(FIPS_F_RSA_EAY_PUBLIC_ENCRYPT,FIPS_R_FIPS_SELFTEST_FAILED);
170                 goto err;
171                 }
172
173         if (FIPS_mode() && (BN_num_bits(rsa->n) < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS))
174                 {
175                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_KEY_SIZE_TOO_SMALL);
176                 return -1;
177                 }
178 #endif
179
180         if (BN_num_bits(rsa->n) > OPENSSL_RSA_MAX_MODULUS_BITS)
181                 {
182                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_MODULUS_TOO_LARGE);
183                 return -1;
184                 }
185
186         if (BN_ucmp(rsa->n, rsa->e) <= 0)
187                 {
188                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_BAD_E_VALUE);
189                 return -1;
190                 }
191
192         /* for large moduli, enforce exponent limit */
193         if (BN_num_bits(rsa->n) > OPENSSL_RSA_SMALL_MODULUS_BITS)
194                 {
195                 if (BN_num_bits(rsa->e) > OPENSSL_RSA_MAX_PUBEXP_BITS)
196                         {
197                         RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_BAD_E_VALUE);
198                         return -1;
199                         }
200                 }
201         
202         if ((ctx=BN_CTX_new()) == NULL) goto err;
203         BN_CTX_start(ctx);
204         f = BN_CTX_get(ctx);
205         ret = BN_CTX_get(ctx);
206         num=BN_num_bytes(rsa->n);
207         buf = OPENSSL_malloc(num);
208         if (!f || !ret || !buf)
209                 {
210                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,ERR_R_MALLOC_FAILURE);
211                 goto err;
212                 }
213
214         switch (padding)
215                 {
216         case RSA_PKCS1_PADDING:
217                 i=RSA_padding_add_PKCS1_type_2(buf,num,from,flen);
218                 break;
219 #ifndef OPENSSL_NO_SHA
220         case RSA_PKCS1_OAEP_PADDING:
221                 i=RSA_padding_add_PKCS1_OAEP(buf,num,from,flen,NULL,0);
222                 break;
223 #endif
224         case RSA_SSLV23_PADDING:
225                 i=RSA_padding_add_SSLv23(buf,num,from,flen);
226                 break;
227         case RSA_NO_PADDING:
228                 i=RSA_padding_add_none(buf,num,from,flen);
229                 break;
230         default:
231                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
232                 goto err;
233                 }
234         if (i <= 0) goto err;
235
236         if (BN_bin2bn(buf,num,f) == NULL) goto err;
237         
238         if (BN_ucmp(f, rsa->n) >= 0)
239                 {
240                 /* usually the padding functions would catch this */
241                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
242                 goto err;
243                 }
244
245         if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
246                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
247                         goto err;
248
249         if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,
250                 rsa->_method_mod_n)) goto err;
251
252         /* put in leading 0 bytes if the number is less than the
253          * length of the modulus */
254         j=BN_num_bytes(ret);
255         i=BN_bn2bin(ret,&(to[num-j]));
256         for (k=0; k<(num-i); k++)
257                 to[k]=0;
258
259         r=num;
260 err:
261         if (ctx != NULL)
262                 {
263                 BN_CTX_end(ctx);
264                 BN_CTX_free(ctx);
265                 }
266         if (buf != NULL) 
267                 {
268                 OPENSSL_cleanse(buf,num);
269                 OPENSSL_free(buf);
270                 }
271         return(r);
272         }
273
274 static BN_BLINDING *rsa_get_blinding(RSA *rsa, int *local, BN_CTX *ctx)
275 {
276         BN_BLINDING *ret;
277         int got_write_lock = 0;
278         CRYPTO_THREADID cur;
279
280         CRYPTO_r_lock(CRYPTO_LOCK_RSA);
281
282         if (rsa->blinding == NULL)
283                 {
284                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
285                 CRYPTO_w_lock(CRYPTO_LOCK_RSA);
286                 got_write_lock = 1;
287
288                 if (rsa->blinding == NULL)
289                         rsa->blinding = RSA_setup_blinding(rsa, ctx);
290                 }
291
292         ret = rsa->blinding;
293         if (ret == NULL)
294                 goto err;
295
296         CRYPTO_THREADID_current(&cur);
297         if (!CRYPTO_THREADID_cmp(&cur, BN_BLINDING_thread_id(ret)))
298                 {
299                 /* rsa->blinding is ours! */
300
301                 *local = 1;
302                 }
303         else
304                 {
305                 /* resort to rsa->mt_blinding instead */
306
307                 *local = 0; /* instructs rsa_blinding_convert(), rsa_blinding_invert()
308                              * that the BN_BLINDING is shared, meaning that accesses
309                              * require locks, and that the blinding factor must be
310                              * stored outside the BN_BLINDING
311                              */
312
313                 if (rsa->mt_blinding == NULL)
314                         {
315                         if (!got_write_lock)
316                                 {
317                                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
318                                 CRYPTO_w_lock(CRYPTO_LOCK_RSA);
319                                 got_write_lock = 1;
320                                 }
321                         
322                         if (rsa->mt_blinding == NULL)
323                                 rsa->mt_blinding = RSA_setup_blinding(rsa, ctx);
324                         }
325                 ret = rsa->mt_blinding;
326                 }
327
328  err:
329         if (got_write_lock)
330                 CRYPTO_w_unlock(CRYPTO_LOCK_RSA);
331         else
332                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
333         return ret;
334 }
335
336 static int rsa_blinding_convert(BN_BLINDING *b, int local, BIGNUM *f,
337         BIGNUM *r, BN_CTX *ctx)
338 {
339         if (local)
340                 return BN_BLINDING_convert_ex(f, NULL, b, ctx);
341         else
342                 {
343                 int ret;
344                 CRYPTO_r_lock(CRYPTO_LOCK_RSA_BLINDING);
345                 ret = BN_BLINDING_convert_ex(f, r, b, ctx);
346                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA_BLINDING);
347                 return ret;
348                 }
349 }
350
351 static int rsa_blinding_invert(BN_BLINDING *b, int local, BIGNUM *f,
352         BIGNUM *r, BN_CTX *ctx)
353 {
354         if (local)
355                 return BN_BLINDING_invert_ex(f, NULL, b, ctx);
356         else
357                 {
358                 int ret;
359                 CRYPTO_w_lock(CRYPTO_LOCK_RSA_BLINDING);
360                 ret = BN_BLINDING_invert_ex(f, r, b, ctx);
361                 CRYPTO_w_unlock(CRYPTO_LOCK_RSA_BLINDING);
362                 return ret;
363                 }
364 }
365
366 /* signing */
367 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
368              unsigned char *to, RSA *rsa, int padding)
369         {
370         BIGNUM *f, *ret, *br, *res;
371         int i,j,k,num=0,r= -1;
372         unsigned char *buf=NULL;
373         BN_CTX *ctx=NULL;
374         int local_blinding = 0;
375         BN_BLINDING *blinding = NULL;
376
377 #ifdef OPENSSL_FIPS
378         if(FIPS_selftest_failed())
379                 {
380                 FIPSerr(FIPS_F_RSA_EAY_PUBLIC_ENCRYPT,FIPS_R_FIPS_SELFTEST_FAILED);
381                 goto err;
382                 }
383
384         if (FIPS_mode() && (BN_num_bits(rsa->n) < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS))
385                 {
386                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_KEY_SIZE_TOO_SMALL);
387                 return -1;
388                 }
389 #endif
390
391         if ((ctx=BN_CTX_new()) == NULL) goto err;
392         BN_CTX_start(ctx);
393         f   = BN_CTX_get(ctx);
394         br  = BN_CTX_get(ctx);
395         ret = BN_CTX_get(ctx);
396         num = BN_num_bytes(rsa->n);
397         buf = OPENSSL_malloc(num);
398         if(!f || !ret || !buf)
399                 {
400                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
401                 goto err;
402                 }
403
404         switch (padding)
405                 {
406         case RSA_PKCS1_PADDING:
407                 i=RSA_padding_add_PKCS1_type_1(buf,num,from,flen);
408                 break;
409         case RSA_X931_PADDING:
410                 i=RSA_padding_add_X931(buf,num,from,flen);
411                 break;
412         case RSA_NO_PADDING:
413                 i=RSA_padding_add_none(buf,num,from,flen);
414                 break;
415         case RSA_SSLV23_PADDING:
416         default:
417                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
418                 goto err;
419                 }
420         if (i <= 0) goto err;
421
422         if (BN_bin2bn(buf,num,f) == NULL) goto err;
423         
424         if (BN_ucmp(f, rsa->n) >= 0)
425                 {       
426                 /* usually the padding functions would catch this */
427                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
428                 goto err;
429                 }
430
431         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
432                 {
433                 blinding = rsa_get_blinding(rsa, &local_blinding, ctx);
434                 if (blinding == NULL)
435                         {
436                         RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT, ERR_R_INTERNAL_ERROR);
437                         goto err;
438                         }
439                 }
440         
441         if (blinding != NULL)
442                 if (!rsa_blinding_convert(blinding, local_blinding, f, br, ctx))
443                         goto err;
444
445         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
446                 ((rsa->p != NULL) &&
447                 (rsa->q != NULL) &&
448                 (rsa->dmp1 != NULL) &&
449                 (rsa->dmq1 != NULL) &&
450                 (rsa->iqmp != NULL)) )
451                 { 
452                 if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
453                 }
454         else
455                 {
456                 BIGNUM local_d;
457                 BIGNUM *d = NULL;
458                 
459                 if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
460                         {
461                         BN_init(&local_d);
462                         d = &local_d;
463                         BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
464                         }
465                 else
466                         d= rsa->d;
467
468                 if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
469                         if(!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
470                                 goto err;
471
472                 if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
473                                 rsa->_method_mod_n)) goto err;
474                 }
475
476         if (blinding)
477                 if (!rsa_blinding_invert(blinding, local_blinding, ret, br, ctx))
478                         goto err;
479
480         if (padding == RSA_X931_PADDING)
481                 {
482                 BN_sub(f, rsa->n, ret);
483                 if (BN_cmp(ret, f))
484                         res = f;
485                 else
486                         res = ret;
487                 }
488         else
489                 res = ret;
490
491         /* put in leading 0 bytes if the number is less than the
492          * length of the modulus */
493         j=BN_num_bytes(res);
494         i=BN_bn2bin(res,&(to[num-j]));
495         for (k=0; k<(num-i); k++)
496                 to[k]=0;
497
498         r=num;
499 err:
500         if (ctx != NULL)
501                 {
502                 BN_CTX_end(ctx);
503                 BN_CTX_free(ctx);
504                 }
505         if (buf != NULL)
506                 {
507                 OPENSSL_cleanse(buf,num);
508                 OPENSSL_free(buf);
509                 }
510         return(r);
511         }
512
513 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
514              unsigned char *to, RSA *rsa, int padding)
515         {
516         BIGNUM *f, *ret, *br;
517         int j,num=0,r= -1;
518         unsigned char *p;
519         unsigned char *buf=NULL;
520         BN_CTX *ctx=NULL;
521         int local_blinding = 0;
522         BN_BLINDING *blinding = NULL;
523
524 #ifdef OPENSSL_FIPS
525         if(FIPS_selftest_failed())
526                 {
527                 FIPSerr(FIPS_F_RSA_EAY_PUBLIC_ENCRYPT,FIPS_R_FIPS_SELFTEST_FAILED);
528                 goto err;
529                 }
530
531         if (FIPS_mode() && (BN_num_bits(rsa->n) < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS))
532                 {
533                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_KEY_SIZE_TOO_SMALL);
534                 return -1;
535                 }
536 #endif
537
538         if((ctx = BN_CTX_new()) == NULL) goto err;
539         BN_CTX_start(ctx);
540         f   = BN_CTX_get(ctx);
541         br  = BN_CTX_get(ctx);
542         ret = BN_CTX_get(ctx);
543         num = BN_num_bytes(rsa->n);
544         buf = OPENSSL_malloc(num);
545         if(!f || !ret || !buf)
546                 {
547                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
548                 goto err;
549                 }
550
551         /* This check was for equality but PGP does evil things
552          * and chops off the top '0' bytes */
553         if (flen > num)
554                 {
555                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
556                 goto err;
557                 }
558
559         /* make data into a big number */
560         if (BN_bin2bn(from,(int)flen,f) == NULL) goto err;
561
562         if (BN_ucmp(f, rsa->n) >= 0)
563                 {
564                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
565                 goto err;
566                 }
567
568         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
569                 {
570                 blinding = rsa_get_blinding(rsa, &local_blinding, ctx);
571                 if (blinding == NULL)
572                         {
573                         RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT, ERR_R_INTERNAL_ERROR);
574                         goto err;
575                         }
576                 }
577         
578         if (blinding != NULL)
579                 if (!rsa_blinding_convert(blinding, local_blinding, f, br, ctx))
580                         goto err;
581
582         /* do the decrypt */
583         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
584                 ((rsa->p != NULL) &&
585                 (rsa->q != NULL) &&
586                 (rsa->dmp1 != NULL) &&
587                 (rsa->dmq1 != NULL) &&
588                 (rsa->iqmp != NULL)) )
589                 {
590                 if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
591                 }
592         else
593                 {
594                 BIGNUM local_d;
595                 BIGNUM *d = NULL;
596                 
597                 if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
598                         {
599                         d = &local_d;
600                         BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
601                         }
602                 else
603                         d = rsa->d;
604
605                 if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
606                         if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
607                                 goto err;
608                 if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
609                                 rsa->_method_mod_n))
610                   goto err;
611                 }
612
613         if (blinding)
614                 if (!rsa_blinding_invert(blinding, local_blinding, ret, br, ctx))
615                         goto err;
616
617         p=buf;
618         j=BN_bn2bin(ret,p); /* j is only used with no-padding mode */
619
620         switch (padding)
621                 {
622         case RSA_PKCS1_PADDING:
623                 r=RSA_padding_check_PKCS1_type_2(to,num,buf,j,num);
624                 break;
625 #ifndef OPENSSL_NO_SHA
626         case RSA_PKCS1_OAEP_PADDING:
627                 r=RSA_padding_check_PKCS1_OAEP(to,num,buf,j,num,NULL,0);
628                 break;
629 #endif
630         case RSA_SSLV23_PADDING:
631                 r=RSA_padding_check_SSLv23(to,num,buf,j,num);
632                 break;
633         case RSA_NO_PADDING:
634                 r=RSA_padding_check_none(to,num,buf,j,num);
635                 break;
636         default:
637                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
638                 goto err;
639                 }
640         if (r < 0)
641                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
642
643 err:
644         if (ctx != NULL)
645                 {
646                 BN_CTX_end(ctx);
647                 BN_CTX_free(ctx);
648                 }
649         if (buf != NULL)
650                 {
651                 OPENSSL_cleanse(buf,num);
652                 OPENSSL_free(buf);
653                 }
654         return(r);
655         }
656
657 /* signature verification */
658 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
659              unsigned char *to, RSA *rsa, int padding)
660         {
661         BIGNUM *f,*ret;
662         int i,num=0,r= -1;
663         unsigned char *p;
664         unsigned char *buf=NULL;
665         BN_CTX *ctx=NULL;
666
667 #ifdef OPENSSL_FIPS
668         if(FIPS_selftest_failed())
669                 {
670                 FIPSerr(FIPS_F_RSA_EAY_PUBLIC_ENCRYPT,FIPS_R_FIPS_SELFTEST_FAILED);
671                 goto err;
672                 }
673
674         if (FIPS_mode() && (BN_num_bits(rsa->n) < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS))
675                 {
676                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_KEY_SIZE_TOO_SMALL);
677                 return -1;
678                 }
679 #endif
680
681         if (BN_num_bits(rsa->n) > OPENSSL_RSA_MAX_MODULUS_BITS)
682                 {
683                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_MODULUS_TOO_LARGE);
684                 return -1;
685                 }
686
687         if (BN_ucmp(rsa->n, rsa->e) <= 0)
688                 {
689                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_BAD_E_VALUE);
690                 return -1;
691                 }
692
693         /* for large moduli, enforce exponent limit */
694         if (BN_num_bits(rsa->n) > OPENSSL_RSA_SMALL_MODULUS_BITS)
695                 {
696                 if (BN_num_bits(rsa->e) > OPENSSL_RSA_MAX_PUBEXP_BITS)
697                         {
698                         RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_BAD_E_VALUE);
699                         return -1;
700                         }
701                 }
702         
703         if((ctx = BN_CTX_new()) == NULL) goto err;
704         BN_CTX_start(ctx);
705         f = BN_CTX_get(ctx);
706         ret = BN_CTX_get(ctx);
707         num=BN_num_bytes(rsa->n);
708         buf = OPENSSL_malloc(num);
709         if(!f || !ret || !buf)
710                 {
711                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
712                 goto err;
713                 }
714
715         /* This check was for equality but PGP does evil things
716          * and chops off the top '0' bytes */
717         if (flen > num)
718                 {
719                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
720                 goto err;
721                 }
722
723         if (BN_bin2bn(from,flen,f) == NULL) goto err;
724
725         if (BN_ucmp(f, rsa->n) >= 0)
726                 {
727                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
728                 goto err;
729                 }
730
731         if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
732                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
733                         goto err;
734
735         if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,
736                 rsa->_method_mod_n)) goto err;
737
738         if ((padding == RSA_X931_PADDING) && ((ret->d[0] & 0xf) != 12))
739                 if (!BN_sub(ret, rsa->n, ret)) goto err;
740
741         p=buf;
742         i=BN_bn2bin(ret,p);
743
744         switch (padding)
745                 {
746         case RSA_PKCS1_PADDING:
747                 r=RSA_padding_check_PKCS1_type_1(to,num,buf,i,num);
748                 break;
749         case RSA_X931_PADDING:
750                 r=RSA_padding_check_X931(to,num,buf,i,num);
751                 break;
752         case RSA_NO_PADDING:
753                 r=RSA_padding_check_none(to,num,buf,i,num);
754                 break;
755         default:
756                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
757                 goto err;
758                 }
759         if (r < 0)
760                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
761
762 err:
763         if (ctx != NULL)
764                 {
765                 BN_CTX_end(ctx);
766                 BN_CTX_free(ctx);
767                 }
768         if (buf != NULL)
769                 {
770                 OPENSSL_cleanse(buf,num);
771                 OPENSSL_free(buf);
772                 }
773         return(r);
774         }
775
776 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
777         {
778         BIGNUM *r1,*m1,*vrfy;
779         BIGNUM local_dmp1,local_dmq1,local_c,local_r1;
780         BIGNUM *dmp1,*dmq1,*c,*pr1;
781         int ret=0;
782
783         BN_CTX_start(ctx);
784         r1 = BN_CTX_get(ctx);
785         m1 = BN_CTX_get(ctx);
786         vrfy = BN_CTX_get(ctx);
787
788         {
789                 BIGNUM local_p, local_q;
790                 BIGNUM *p = NULL, *q = NULL;
791
792                 /* Make sure BN_mod_inverse in Montgomery intialization uses the
793                  * BN_FLG_CONSTTIME flag (unless RSA_FLAG_NO_CONSTTIME is set)
794                  */
795                 if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
796                         {
797                         BN_init(&local_p);
798                         p = &local_p;
799                         BN_with_flags(p, rsa->p, BN_FLG_CONSTTIME);
800
801                         BN_init(&local_q);
802                         q = &local_q;
803                         BN_with_flags(q, rsa->q, BN_FLG_CONSTTIME);
804                         }
805                 else
806                         {
807                         p = rsa->p;
808                         q = rsa->q;
809                         }
810
811                 if (rsa->flags & RSA_FLAG_CACHE_PRIVATE)
812                         {
813                         if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_p, CRYPTO_LOCK_RSA, p, ctx))
814                                 goto err;
815                         if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_q, CRYPTO_LOCK_RSA, q, ctx))
816                                 goto err;
817                         }
818         }
819
820         if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
821                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
822                         goto err;
823
824         /* compute I mod q */
825         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
826                 {
827                 c = &local_c;
828                 BN_with_flags(c, I, BN_FLG_CONSTTIME);
829                 if (!BN_mod(r1,c,rsa->q,ctx)) goto err;
830                 }
831         else
832                 {
833                 if (!BN_mod(r1,I,rsa->q,ctx)) goto err;
834                 }
835
836         /* compute r1^dmq1 mod q */
837         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
838                 {
839                 dmq1 = &local_dmq1;
840                 BN_with_flags(dmq1, rsa->dmq1, BN_FLG_CONSTTIME);
841                 }
842         else
843                 dmq1 = rsa->dmq1;
844         if (!rsa->meth->bn_mod_exp(m1,r1,dmq1,rsa->q,ctx,
845                 rsa->_method_mod_q)) goto err;
846
847         /* compute I mod p */
848         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
849                 {
850                 c = &local_c;
851                 BN_with_flags(c, I, BN_FLG_CONSTTIME);
852                 if (!BN_mod(r1,c,rsa->p,ctx)) goto err;
853                 }
854         else
855                 {
856                 if (!BN_mod(r1,I,rsa->p,ctx)) goto err;
857                 }
858
859         /* compute r1^dmp1 mod p */
860         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
861                 {
862                 dmp1 = &local_dmp1;
863                 BN_with_flags(dmp1, rsa->dmp1, BN_FLG_CONSTTIME);
864                 }
865         else
866                 dmp1 = rsa->dmp1;
867         if (!rsa->meth->bn_mod_exp(r0,r1,dmp1,rsa->p,ctx,
868                 rsa->_method_mod_p)) goto err;
869
870         if (!BN_sub(r0,r0,m1)) goto err;
871         /* This will help stop the size of r0 increasing, which does
872          * affect the multiply if it optimised for a power of 2 size */
873         if (BN_is_negative(r0))
874                 if (!BN_add(r0,r0,rsa->p)) goto err;
875
876         if (!BN_mul(r1,r0,rsa->iqmp,ctx)) goto err;
877
878         /* Turn BN_FLG_CONSTTIME flag on before division operation */
879         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
880                 {
881                 pr1 = &local_r1;
882                 BN_with_flags(pr1, r1, BN_FLG_CONSTTIME);
883                 }
884         else
885                 pr1 = r1;
886         if (!BN_mod(r0,pr1,rsa->p,ctx)) goto err;
887
888         /* If p < q it is occasionally possible for the correction of
889          * adding 'p' if r0 is negative above to leave the result still
890          * negative. This can break the private key operations: the following
891          * second correction should *always* correct this rare occurrence.
892          * This will *never* happen with OpenSSL generated keys because
893          * they ensure p > q [steve]
894          */
895         if (BN_is_negative(r0))
896                 if (!BN_add(r0,r0,rsa->p)) goto err;
897         if (!BN_mul(r1,r0,rsa->q,ctx)) goto err;
898         if (!BN_add(r0,r1,m1)) goto err;
899
900         if (rsa->e && rsa->n)
901                 {
902                 if (!rsa->meth->bn_mod_exp(vrfy,r0,rsa->e,rsa->n,ctx,rsa->_method_mod_n)) goto err;
903                 /* If 'I' was greater than (or equal to) rsa->n, the operation
904                  * will be equivalent to using 'I mod n'. However, the result of
905                  * the verify will *always* be less than 'n' so we don't check
906                  * for absolute equality, just congruency. */
907                 if (!BN_sub(vrfy, vrfy, I)) goto err;
908                 if (!BN_mod(vrfy, vrfy, rsa->n, ctx)) goto err;
909                 if (BN_is_negative(vrfy))
910                         if (!BN_add(vrfy, vrfy, rsa->n)) goto err;
911                 if (!BN_is_zero(vrfy))
912                         {
913                         /* 'I' and 'vrfy' aren't congruent mod n. Don't leak
914                          * miscalculated CRT output, just do a raw (slower)
915                          * mod_exp and return that instead. */
916
917                         BIGNUM local_d;
918                         BIGNUM *d = NULL;
919                 
920                         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
921                                 {
922                                 d = &local_d;
923                                 BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
924                                 }
925                         else
926                                 d = rsa->d;
927                         if (!rsa->meth->bn_mod_exp(r0,I,d,rsa->n,ctx,
928                                                    rsa->_method_mod_n)) goto err;
929                         }
930                 }
931         ret=1;
932 err:
933         BN_CTX_end(ctx);
934         return(ret);
935         }
936
937 static int RSA_eay_init(RSA *rsa)
938         {
939 #ifdef OPENSSL_FIPS
940         FIPS_selftest_check();
941 #endif
942         rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
943         return(1);
944         }
945
946 static int RSA_eay_finish(RSA *rsa)
947         {
948         if (rsa->_method_mod_n != NULL)
949                 BN_MONT_CTX_free(rsa->_method_mod_n);
950         if (rsa->_method_mod_p != NULL)
951                 BN_MONT_CTX_free(rsa->_method_mod_p);
952         if (rsa->_method_mod_q != NULL)
953                 BN_MONT_CTX_free(rsa->_method_mod_q);
954         return(1);
955         }
956
957 #endif