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