Use BN_with_flags() in a cleaner way.
[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-2005 The OpenSSL Project.  All rights reserved.
60  *
61  * Redistribution and use in source and binary forms, with or without
62  * modification, are permitted provided that the following conditions
63  * are met:
64  *
65  * 1. Redistributions of source code must retain the above copyright
66  *    notice, this list of conditions and the following disclaimer. 
67  *
68  * 2. Redistributions in binary form must reproduce the above copyright
69  *    notice, this list of conditions and the following disclaimer in
70  *    the documentation and/or other materials provided with the
71  *    distribution.
72  *
73  * 3. All advertising materials mentioning features or use of this
74  *    software must display the following acknowledgment:
75  *    "This product includes software developed by the OpenSSL Project
76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77  *
78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79  *    endorse or promote products derived from this software without
80  *    prior written permission. For written permission, please contact
81  *    openssl-core@openssl.org.
82  *
83  * 5. Products derived from this software may not be called "OpenSSL"
84  *    nor may "OpenSSL" appear in their names without prior written
85  *    permission of the OpenSSL Project.
86  *
87  * 6. Redistributions of any form whatsoever must retain the following
88  *    acknowledgment:
89  *    "This product includes software developed by the OpenSSL Project
90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91  *
92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103  * OF THE POSSIBILITY OF SUCH DAMAGE.
104  * ====================================================================
105  *
106  * This product includes cryptographic software written by Eric Young
107  * (eay@cryptsoft.com).  This product includes software written by Tim
108  * Hudson (tjh@cryptsoft.com).
109  *
110  */
111
112 #include <stdio.h>
113 #include "cryptlib.h"
114 #include <openssl/bn.h>
115 #include <openssl/rsa.h>
116 #include <openssl/rand.h>
117
118 #ifndef RSA_NULL
119
120 static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
121                 unsigned char *to, RSA *rsa,int padding);
122 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
123                 unsigned char *to, RSA *rsa,int padding);
124 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
125                 unsigned char *to, RSA *rsa,int padding);
126 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
127                 unsigned char *to, RSA *rsa,int padding);
128 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *i, RSA *rsa, BN_CTX *ctx);
129 static int RSA_eay_init(RSA *rsa);
130 static int RSA_eay_finish(RSA *rsa);
131 static RSA_METHOD rsa_pkcs1_eay_meth={
132         "Eric Young's PKCS#1 RSA",
133         RSA_eay_public_encrypt,
134         RSA_eay_public_decrypt, /* signature verification */
135         RSA_eay_private_encrypt, /* signing */
136         RSA_eay_private_decrypt,
137         RSA_eay_mod_exp,
138         BN_mod_exp_mont, /* XXX probably we should not use Montgomery if  e == 3 */
139         RSA_eay_init,
140         RSA_eay_finish,
141         0, /* flags */
142         NULL,
143         0, /* rsa_sign */
144         0, /* rsa_verify */
145         NULL /* rsa_keygen */
146         };
147
148 const RSA_METHOD *RSA_PKCS1_SSLeay(void)
149         {
150         return(&rsa_pkcs1_eay_meth);
151         }
152
153 /* Usage example;
154  *    MONT_HELPER(rsa, bn_ctx, p, rsa->flags & RSA_FLAG_CACHE_PRIVATE, goto err);
155  */
156 #define MONT_HELPER(rsa, ctx, m, pre_cond, err_instr) \
157         if((pre_cond) && ((rsa)->_method_mod_##m == NULL) && \
158                         !BN_MONT_CTX_set_locked(&((rsa)->_method_mod_##m), \
159                                 CRYPTO_LOCK_RSA, \
160                                 (rsa)->m, (ctx))) \
161                 err_instr
162
163 static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
164              unsigned char *to, RSA *rsa, int padding)
165         {
166         BIGNUM *f,*ret;
167         int i,j,k,num=0,r= -1;
168         unsigned char *buf=NULL;
169         BN_CTX *ctx=NULL;
170
171         if ((ctx=BN_CTX_new()) == NULL) goto err;
172         BN_CTX_start(ctx);
173         f = BN_CTX_get(ctx);
174         ret = BN_CTX_get(ctx);
175         num=BN_num_bytes(rsa->n);
176         buf = OPENSSL_malloc(num);
177         if (!f || !ret || !buf)
178                 {
179                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,ERR_R_MALLOC_FAILURE);
180                 goto err;
181                 }
182
183         switch (padding)
184                 {
185         case RSA_PKCS1_PADDING:
186                 i=RSA_padding_add_PKCS1_type_2(buf,num,from,flen);
187                 break;
188 #ifndef OPENSSL_NO_SHA
189         case RSA_PKCS1_OAEP_PADDING:
190                 i=RSA_padding_add_PKCS1_OAEP(buf,num,from,flen,NULL,0);
191                 break;
192 #endif
193         case RSA_SSLV23_PADDING:
194                 i=RSA_padding_add_SSLv23(buf,num,from,flen);
195                 break;
196         case RSA_NO_PADDING:
197                 i=RSA_padding_add_none(buf,num,from,flen);
198                 break;
199         default:
200                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
201                 goto err;
202                 }
203         if (i <= 0) goto err;
204
205         if (BN_bin2bn(buf,num,f) == NULL) goto err;
206         
207         if (BN_ucmp(f, rsa->n) >= 0)
208                 {       
209                 /* usually the padding functions would catch this */
210                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
211                 goto err;
212                 }
213
214         MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
215
216         if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,
217                 rsa->_method_mod_n)) goto err;
218
219         /* put in leading 0 bytes if the number is less than the
220          * length of the modulus */
221         j=BN_num_bytes(ret);
222         i=BN_bn2bin(ret,&(to[num-j]));
223         for (k=0; k<(num-i); k++)
224                 to[k]=0;
225
226         r=num;
227 err:
228         if (ctx != NULL)
229                 {
230                 BN_CTX_end(ctx);
231                 BN_CTX_free(ctx);
232                 }
233         if (buf != NULL) 
234                 {
235                 OPENSSL_cleanse(buf,num);
236                 OPENSSL_free(buf);
237                 }
238         return(r);
239         }
240
241 static BN_BLINDING *rsa_get_blinding(RSA *rsa, BIGNUM **r, int *local, BN_CTX *ctx)
242 {
243         BN_BLINDING *ret;
244
245         if (rsa->blinding == NULL)
246                 {
247                 if (rsa->blinding == NULL)
248                         {
249                         CRYPTO_w_lock(CRYPTO_LOCK_RSA);
250                         if (rsa->blinding == NULL)
251                                 rsa->blinding = RSA_setup_blinding(rsa, ctx);
252                         CRYPTO_w_unlock(CRYPTO_LOCK_RSA);
253                         }
254                 }
255
256         ret = rsa->blinding;
257         if (ret == NULL)
258                 return NULL;
259
260         if (BN_BLINDING_get_thread_id(ret) != CRYPTO_thread_id())
261                 {
262                 *local = 0;
263                 if (rsa->mt_blinding == NULL)
264                         {
265                         CRYPTO_w_lock(CRYPTO_LOCK_RSA);
266                         if (rsa->mt_blinding == NULL)
267                                 rsa->mt_blinding = RSA_setup_blinding(rsa, ctx);
268                         CRYPTO_w_unlock(CRYPTO_LOCK_RSA);
269                         }
270                 ret = rsa->mt_blinding;
271                 }
272         else
273                 *local = 1;
274
275         return ret;
276 }
277
278 static int rsa_blinding_convert(BN_BLINDING *b, int local, BIGNUM *f,
279         BIGNUM *r, BN_CTX *ctx)
280 {
281         if (local)
282                 return BN_BLINDING_convert_ex(f, NULL, b, ctx);
283         else
284                 {
285                 int ret;
286                 CRYPTO_w_lock(CRYPTO_LOCK_RSA_BLINDING);
287                 ret = BN_BLINDING_convert_ex(f, r, b, ctx);
288                 CRYPTO_w_unlock(CRYPTO_LOCK_RSA_BLINDING);
289                 return ret;
290                 }
291 }
292
293 static int rsa_blinding_invert(BN_BLINDING *b, int local, BIGNUM *f,
294         BIGNUM *r, BN_CTX *ctx)
295 {
296         if (local)
297                 return BN_BLINDING_invert_ex(f, NULL, b, ctx);
298         else
299                 {
300                 int ret;
301                 CRYPTO_r_lock(CRYPTO_LOCK_RSA_BLINDING);
302                 ret = BN_BLINDING_invert_ex(f, r, b, ctx);
303                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA_BLINDING);
304                 return ret;
305                 }
306 }
307
308 /* signing */
309 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
310              unsigned char *to, RSA *rsa, int padding)
311         {
312         BIGNUM *f, *ret, *br;
313         int i,j,k,num=0,r= -1;
314         unsigned char *buf=NULL;
315         BN_CTX *ctx=NULL;
316         int local_blinding = 0;
317         BN_BLINDING *blinding = NULL;
318
319         if ((ctx=BN_CTX_new()) == NULL) goto err;
320         BN_CTX_start(ctx);
321         f   = BN_CTX_get(ctx);
322         br  = BN_CTX_get(ctx);
323         ret = BN_CTX_get(ctx);
324         num = BN_num_bytes(rsa->n);
325         buf = OPENSSL_malloc(num);
326         if(!f || !ret || !buf)
327                 {
328                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
329                 goto err;
330                 }
331
332         switch (padding)
333                 {
334         case RSA_PKCS1_PADDING:
335                 i=RSA_padding_add_PKCS1_type_1(buf,num,from,flen);
336                 break;
337         case RSA_NO_PADDING:
338                 i=RSA_padding_add_none(buf,num,from,flen);
339                 break;
340         case RSA_SSLV23_PADDING:
341         default:
342                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
343                 goto err;
344                 }
345         if (i <= 0) goto err;
346
347         if (BN_bin2bn(buf,num,f) == NULL) goto err;
348         
349         if (BN_ucmp(f, rsa->n) >= 0)
350                 {       
351                 /* usually the padding functions would catch this */
352                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
353                 goto err;
354                 }
355
356         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
357                 {
358                 blinding = rsa_get_blinding(rsa, &br, &local_blinding, ctx);
359                 if (blinding == NULL)
360                         {
361                         RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT, ERR_R_INTERNAL_ERROR);
362                         goto err;
363                         }
364                 }
365         
366         if (blinding != NULL)
367                 if (!rsa_blinding_convert(blinding, local_blinding, f, br, ctx))
368                         goto err;
369
370         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
371                 ((rsa->p != NULL) &&
372                 (rsa->q != NULL) &&
373                 (rsa->dmp1 != NULL) &&
374                 (rsa->dmq1 != NULL) &&
375                 (rsa->iqmp != NULL)) )
376                 { 
377                 if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
378                 }
379         else
380                 {
381                 BIGNUM local_d;
382                 BIGNUM *d = NULL;
383                 
384                 if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
385                         {
386                         BN_init(&local_d);
387                         d = &local_d;
388                         BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
389                         }
390                 else
391                         d = rsa->d;
392
393                 MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
394
395                 if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
396                                 rsa->_method_mod_n)) goto err;
397                 }
398
399         if (blinding)
400                 if (!rsa_blinding_invert(blinding, local_blinding, ret, br, ctx))
401                         goto err;
402
403         /* put in leading 0 bytes if the number is less than the
404          * length of the modulus */
405         j=BN_num_bytes(ret);
406         i=BN_bn2bin(ret,&(to[num-j]));
407         for (k=0; k<(num-i); k++)
408                 to[k]=0;
409
410         r=num;
411 err:
412         if (ctx != NULL)
413                 {
414                 BN_CTX_end(ctx);
415                 BN_CTX_free(ctx);
416                 }
417         if (buf != NULL)
418                 {
419                 OPENSSL_cleanse(buf,num);
420                 OPENSSL_free(buf);
421                 }
422         return(r);
423         }
424
425 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
426              unsigned char *to, RSA *rsa, int padding)
427         {
428         BIGNUM *f, *ret, *br;
429         int j,num=0,r= -1;
430         unsigned char *p;
431         unsigned char *buf=NULL;
432         BN_CTX *ctx=NULL;
433         int local_blinding = 0;
434         BN_BLINDING *blinding = NULL;
435
436         if((ctx = BN_CTX_new()) == NULL) goto err;
437         BN_CTX_start(ctx);
438         f   = BN_CTX_get(ctx);
439         br  = BN_CTX_get(ctx);
440         ret = BN_CTX_get(ctx);
441         num = BN_num_bytes(rsa->n);
442         buf = OPENSSL_malloc(num);
443         if(!f || !ret || !buf)
444                 {
445                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
446                 goto err;
447                 }
448
449         /* This check was for equality but PGP does evil things
450          * and chops off the top '0' bytes */
451         if (flen > num)
452                 {
453                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
454                 goto err;
455                 }
456
457         /* make data into a big number */
458         if (BN_bin2bn(from,(int)flen,f) == NULL) goto err;
459
460         if (BN_ucmp(f, rsa->n) >= 0)
461                 {
462                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
463                 goto err;
464                 }
465
466         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
467                 {
468                 blinding = rsa_get_blinding(rsa, &br, &local_blinding, ctx);
469                 if (blinding == NULL)
470                         {
471                         RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT, ERR_R_INTERNAL_ERROR);
472                         goto err;
473                         }
474                 }
475         
476         if (blinding != NULL)
477                 if (!rsa_blinding_convert(blinding, local_blinding, f, br, ctx))
478                         goto err;
479
480         /* do the decrypt */
481         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
482                 ((rsa->p != NULL) &&
483                 (rsa->q != NULL) &&
484                 (rsa->dmp1 != NULL) &&
485                 (rsa->dmq1 != NULL) &&
486                 (rsa->iqmp != NULL)) )
487                 {
488                 if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
489                 }
490         else
491                 {
492                 BIGNUM local_d;
493                 BIGNUM *d = NULL;
494                 
495                 if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
496                         {
497                         d = &local_d;
498                         BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
499                         }
500                 else
501                         d = rsa->d;
502
503                 MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
504                 if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
505                                 rsa->_method_mod_n))
506                   goto err;
507                 }
508
509         if (blinding)
510                 if (!rsa_blinding_invert(blinding, local_blinding, ret, br, ctx))
511                         goto err;
512
513         p=buf;
514         j=BN_bn2bin(ret,p); /* j is only used with no-padding mode */
515
516         switch (padding)
517                 {
518         case RSA_PKCS1_PADDING:
519                 r=RSA_padding_check_PKCS1_type_2(to,num,buf,j,num);
520                 break;
521 #ifndef OPENSSL_NO_SHA
522         case RSA_PKCS1_OAEP_PADDING:
523                 r=RSA_padding_check_PKCS1_OAEP(to,num,buf,j,num,NULL,0);
524                 break;
525 #endif
526         case RSA_SSLV23_PADDING:
527                 r=RSA_padding_check_SSLv23(to,num,buf,j,num);
528                 break;
529         case RSA_NO_PADDING:
530                 r=RSA_padding_check_none(to,num,buf,j,num);
531                 break;
532         default:
533                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
534                 goto err;
535                 }
536         if (r < 0)
537                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
538
539 err:
540         if (ctx != NULL)
541                 {
542                 BN_CTX_end(ctx);
543                 BN_CTX_free(ctx);
544                 }
545         if (buf != NULL)
546                 {
547                 OPENSSL_cleanse(buf,num);
548                 OPENSSL_free(buf);
549                 }
550         return(r);
551         }
552
553 /* signature verification */
554 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
555              unsigned char *to, RSA *rsa, int padding)
556         {
557         BIGNUM *f,*ret;
558         int i,num=0,r= -1;
559         unsigned char *p;
560         unsigned char *buf=NULL;
561         BN_CTX *ctx=NULL;
562
563         if((ctx = BN_CTX_new()) == NULL) goto err;
564         BN_CTX_start(ctx);
565         f = BN_CTX_get(ctx);
566         ret = BN_CTX_get(ctx);
567         num=BN_num_bytes(rsa->n);
568         buf = OPENSSL_malloc(num);
569         if(!f || !ret || !buf)
570                 {
571                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
572                 goto err;
573                 }
574
575         /* This check was for equality but PGP does evil things
576          * and chops off the top '0' bytes */
577         if (flen > num)
578                 {
579                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
580                 goto err;
581                 }
582
583         if (BN_bin2bn(from,flen,f) == NULL) goto err;
584
585         if (BN_ucmp(f, rsa->n) >= 0)
586                 {
587                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
588                 goto err;
589                 }
590
591         MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
592
593         if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,
594                 rsa->_method_mod_n)) goto err;
595
596         p=buf;
597         i=BN_bn2bin(ret,p);
598
599         switch (padding)
600                 {
601         case RSA_PKCS1_PADDING:
602                 r=RSA_padding_check_PKCS1_type_1(to,num,buf,i,num);
603                 break;
604         case RSA_NO_PADDING:
605                 r=RSA_padding_check_none(to,num,buf,i,num);
606                 break;
607         default:
608                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
609                 goto err;
610                 }
611         if (r < 0)
612                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
613
614 err:
615         if (ctx != NULL)
616                 {
617                 BN_CTX_end(ctx);
618                 BN_CTX_free(ctx);
619                 }
620         if (buf != NULL)
621                 {
622                 OPENSSL_cleanse(buf,num);
623                 OPENSSL_free(buf);
624                 }
625         return(r);
626         }
627
628 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
629         {
630         BIGNUM *r1,*m1,*vrfy;
631         BIGNUM local_dmp1, local_dmq1;
632         BIGNUM *dmp1, *dmq1;
633         int ret=0;
634
635         BN_CTX_start(ctx);
636         r1 = BN_CTX_get(ctx);
637         m1 = BN_CTX_get(ctx);
638         vrfy = BN_CTX_get(ctx);
639
640         MONT_HELPER(rsa, ctx, p, rsa->flags & RSA_FLAG_CACHE_PRIVATE, goto err);
641         MONT_HELPER(rsa, ctx, q, rsa->flags & RSA_FLAG_CACHE_PRIVATE, goto err);
642         MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
643
644         if (!BN_mod(r1,I,rsa->q,ctx)) goto err;
645         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
646                 {
647                 dmq1 = &local_dmq1;
648                 BN_with_flags(dmq1, rsa->dmq1, BN_FLG_EXP_CONSTTIME);
649                 }
650         else
651                 dmq1 = rsa->dmq1;
652         if (!rsa->meth->bn_mod_exp(m1,r1,dmq1,rsa->q,ctx,
653                 rsa->_method_mod_q)) goto err;
654
655         if (!BN_mod(r1,I,rsa->p,ctx)) goto err;
656         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
657                 {
658                 dmp1 = &local_dmp1;
659                 BN_with_flags(dmp1, rsa->dmp1, BN_FLG_EXP_CONSTTIME);
660                 }
661         else
662                 dmp1 = rsa->dmp1;
663         if (!rsa->meth->bn_mod_exp(r0,r1,dmp1,rsa->p,ctx,
664                 rsa->_method_mod_p)) goto err;
665
666         if (!BN_sub(r0,r0,m1)) goto err;
667         /* This will help stop the size of r0 increasing, which does
668          * affect the multiply if it optimised for a power of 2 size */
669         if (BN_is_negative(r0))
670                 if (!BN_add(r0,r0,rsa->p)) goto err;
671
672         if (!BN_mul(r1,r0,rsa->iqmp,ctx)) goto err;
673         if (!BN_mod(r0,r1,rsa->p,ctx)) goto err;
674         /* If p < q it is occasionally possible for the correction of
675          * adding 'p' if r0 is negative above to leave the result still
676          * negative. This can break the private key operations: the following
677          * second correction should *always* correct this rare occurrence.
678          * This will *never* happen with OpenSSL generated keys because
679          * they ensure p > q [steve]
680          */
681         if (BN_is_negative(r0))
682                 if (!BN_add(r0,r0,rsa->p)) goto err;
683         if (!BN_mul(r1,r0,rsa->q,ctx)) goto err;
684         if (!BN_add(r0,r1,m1)) goto err;
685
686         if (rsa->e && rsa->n)
687                 {
688                 if (!rsa->meth->bn_mod_exp(vrfy,r0,rsa->e,rsa->n,ctx,rsa->_method_mod_n)) goto err;
689                 /* If 'I' was greater than (or equal to) rsa->n, the operation
690                  * will be equivalent to using 'I mod n'. However, the result of
691                  * the verify will *always* be less than 'n' so we don't check
692                  * for absolute equality, just congruency. */
693                 if (!BN_sub(vrfy, vrfy, I)) goto err;
694                 if (!BN_mod(vrfy, vrfy, rsa->n, ctx)) goto err;
695                 if (BN_is_negative(vrfy))
696                         if (!BN_add(vrfy, vrfy, rsa->n)) goto err;
697                 if (!BN_is_zero(vrfy))
698                         {
699                         /* 'I' and 'vrfy' aren't congruent mod n. Don't leak
700                          * miscalculated CRT output, just do a raw (slower)
701                          * mod_exp and return that instead. */
702
703                         BIGNUM local_d;
704                         BIGNUM *d = NULL;
705                 
706                         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
707                                 {
708                                 d = &local_d;
709                                 BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
710                                 }
711                         else
712                                 d = rsa->d;
713                         if (!rsa->meth->bn_mod_exp(r0,I,d,rsa->n,ctx,
714                                                    rsa->_method_mod_n)) goto err;
715                         }
716                 }
717         ret=1;
718 err:
719         BN_CTX_end(ctx);
720         return(ret);
721         }
722
723 static int RSA_eay_init(RSA *rsa)
724         {
725         rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
726         return(1);
727         }
728
729 static int RSA_eay_finish(RSA *rsa)
730         {
731         if (rsa->_method_mod_n != NULL)
732                 BN_MONT_CTX_free(rsa->_method_mod_n);
733         if (rsa->_method_mod_p != NULL)
734                 BN_MONT_CTX_free(rsa->_method_mod_p);
735         if (rsa->_method_mod_q != NULL)
736                 BN_MONT_CTX_free(rsa->_method_mod_q);
737         return(1);
738         }
739
740 #endif