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