Avoid PKCS #1 v1.5 signature attack discovered by Daniel Bleichenbacher
[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 #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, int *local, BN_CTX *ctx)
242 {
243         BN_BLINDING *ret;
244         int got_write_lock = 0;
245
246         CRYPTO_r_lock(CRYPTO_LOCK_RSA);
247
248         if (rsa->blinding == NULL)
249                 {
250                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
251                 CRYPTO_w_lock(CRYPTO_LOCK_RSA);
252                 got_write_lock = 1;
253
254                 if (rsa->blinding == NULL)
255                         rsa->blinding = RSA_setup_blinding(rsa, ctx);
256                 }
257
258         ret = rsa->blinding;
259         if (ret == NULL)
260                 goto err;
261
262         if ((BN_BLINDING_get_thread_id(ret) == CRYPTO_thread_id()) && (BN_BLINDING_get_thread_idptr(ret) == CRYPTO_thread_idptr()))
263                 {
264                 /* rsa->blinding is ours! */
265
266                 *local = 1;
267                 }
268         else
269                 {
270                 /* resort to rsa->mt_blinding instead */
271
272                 *local = 0; /* instructs rsa_blinding_convert(), rsa_blinding_invert()
273                              * that the BN_BLINDING is shared, meaning that accesses
274                              * require locks, and that the blinding factor must be
275                              * stored outside the BN_BLINDING
276                              */
277
278                 if (rsa->mt_blinding == NULL)
279                         {
280                         if (!got_write_lock)
281                                 {
282                                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
283                                 CRYPTO_w_lock(CRYPTO_LOCK_RSA);
284                                 got_write_lock = 1;
285                                 }
286                         
287                         if (rsa->mt_blinding == NULL)
288                                 rsa->mt_blinding = RSA_setup_blinding(rsa, ctx);
289                         }
290                 ret = rsa->mt_blinding;
291                 }
292
293  err:
294         if (got_write_lock)
295                 CRYPTO_w_unlock(CRYPTO_LOCK_RSA);
296         else
297                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
298         return ret;
299 }
300
301 static int rsa_blinding_convert(BN_BLINDING *b, int local, BIGNUM *f,
302         BIGNUM *r, BN_CTX *ctx)
303 {
304         if (local)
305                 return BN_BLINDING_convert_ex(f, NULL, b, ctx);
306         else
307                 {
308                 int ret;
309                 CRYPTO_r_lock(CRYPTO_LOCK_RSA_BLINDING);
310                 ret = BN_BLINDING_convert_ex(f, r, b, ctx);
311                 CRYPTO_r_unlock(CRYPTO_LOCK_RSA_BLINDING);
312                 return ret;
313                 }
314 }
315
316 static int rsa_blinding_invert(BN_BLINDING *b, int local, BIGNUM *f,
317         BIGNUM *r, BN_CTX *ctx)
318 {
319         if (local)
320                 return BN_BLINDING_invert_ex(f, NULL, b, ctx);
321         else
322                 {
323                 int ret;
324                 CRYPTO_w_lock(CRYPTO_LOCK_RSA_BLINDING);
325                 ret = BN_BLINDING_invert_ex(f, r, b, ctx);
326                 CRYPTO_w_unlock(CRYPTO_LOCK_RSA_BLINDING);
327                 return ret;
328                 }
329 }
330
331 /* signing */
332 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
333              unsigned char *to, RSA *rsa, int padding)
334         {
335         BIGNUM *f, *ret, *br, *res;
336         int i,j,k,num=0,r= -1;
337         unsigned char *buf=NULL;
338         BN_CTX *ctx=NULL;
339         int local_blinding = 0;
340         BN_BLINDING *blinding = NULL;
341
342         if ((ctx=BN_CTX_new()) == NULL) goto err;
343         BN_CTX_start(ctx);
344         f   = BN_CTX_get(ctx);
345         br  = BN_CTX_get(ctx);
346         ret = BN_CTX_get(ctx);
347         num = BN_num_bytes(rsa->n);
348         buf = OPENSSL_malloc(num);
349         if(!f || !ret || !buf)
350                 {
351                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
352                 goto err;
353                 }
354
355         switch (padding)
356                 {
357         case RSA_PKCS1_PADDING:
358                 i=RSA_padding_add_PKCS1_type_1(buf,num,from,flen);
359                 break;
360         case RSA_X931_PADDING:
361                 i=RSA_padding_add_X931(buf,num,from,flen);
362                 break;
363         case RSA_NO_PADDING:
364                 i=RSA_padding_add_none(buf,num,from,flen);
365                 break;
366         case RSA_SSLV23_PADDING:
367         default:
368                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
369                 goto err;
370                 }
371         if (i <= 0) goto err;
372
373         if (BN_bin2bn(buf,num,f) == NULL) goto err;
374         
375         if (BN_ucmp(f, rsa->n) >= 0)
376                 {       
377                 /* usually the padding functions would catch this */
378                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
379                 goto err;
380                 }
381
382         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
383                 {
384                 blinding = rsa_get_blinding(rsa, &local_blinding, ctx);
385                 if (blinding == NULL)
386                         {
387                         RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT, ERR_R_INTERNAL_ERROR);
388                         goto err;
389                         }
390                 }
391         
392         if (blinding != NULL)
393                 if (!rsa_blinding_convert(blinding, local_blinding, f, br, ctx))
394                         goto err;
395
396         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
397                 ((rsa->p != NULL) &&
398                 (rsa->q != NULL) &&
399                 (rsa->dmp1 != NULL) &&
400                 (rsa->dmq1 != NULL) &&
401                 (rsa->iqmp != NULL)) )
402                 { 
403                 if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
404                 }
405         else
406                 {
407                 BIGNUM local_d;
408                 BIGNUM *d = NULL;
409                 
410                 if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
411                         {
412                         BN_init(&local_d);
413                         d = &local_d;
414                         BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
415                         }
416                 else
417                         d = rsa->d;
418
419                 MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
420
421                 if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
422                                 rsa->_method_mod_n)) goto err;
423                 }
424
425         if (blinding)
426                 if (!rsa_blinding_invert(blinding, local_blinding, ret, br, ctx))
427                         goto err;
428
429         if (padding == RSA_X931_PADDING)
430                 {
431                 BN_sub(f, rsa->n, ret);
432                 if (BN_cmp(ret, f))
433                         res = f;
434                 else
435                         res = ret;
436                 }
437         else
438                 res = ret;
439
440         /* put in leading 0 bytes if the number is less than the
441          * length of the modulus */
442         j=BN_num_bytes(res);
443         i=BN_bn2bin(res,&(to[num-j]));
444         for (k=0; k<(num-i); k++)
445                 to[k]=0;
446
447         r=num;
448 err:
449         if (ctx != NULL)
450                 {
451                 BN_CTX_end(ctx);
452                 BN_CTX_free(ctx);
453                 }
454         if (buf != NULL)
455                 {
456                 OPENSSL_cleanse(buf,num);
457                 OPENSSL_free(buf);
458                 }
459         return(r);
460         }
461
462 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
463              unsigned char *to, RSA *rsa, int padding)
464         {
465         BIGNUM *f, *ret, *br;
466         int j,num=0,r= -1;
467         unsigned char *p;
468         unsigned char *buf=NULL;
469         BN_CTX *ctx=NULL;
470         int local_blinding = 0;
471         BN_BLINDING *blinding = NULL;
472
473         if((ctx = BN_CTX_new()) == NULL) goto err;
474         BN_CTX_start(ctx);
475         f   = BN_CTX_get(ctx);
476         br  = BN_CTX_get(ctx);
477         ret = BN_CTX_get(ctx);
478         num = BN_num_bytes(rsa->n);
479         buf = OPENSSL_malloc(num);
480         if(!f || !ret || !buf)
481                 {
482                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
483                 goto err;
484                 }
485
486         /* This check was for equality but PGP does evil things
487          * and chops off the top '0' bytes */
488         if (flen > num)
489                 {
490                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
491                 goto err;
492                 }
493
494         /* make data into a big number */
495         if (BN_bin2bn(from,(int)flen,f) == NULL) goto err;
496
497         if (BN_ucmp(f, rsa->n) >= 0)
498                 {
499                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
500                 goto err;
501                 }
502
503         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
504                 {
505                 blinding = rsa_get_blinding(rsa, &local_blinding, ctx);
506                 if (blinding == NULL)
507                         {
508                         RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT, ERR_R_INTERNAL_ERROR);
509                         goto err;
510                         }
511                 }
512         
513         if (blinding != NULL)
514                 if (!rsa_blinding_convert(blinding, local_blinding, f, br, ctx))
515                         goto err;
516
517         /* do the decrypt */
518         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
519                 ((rsa->p != NULL) &&
520                 (rsa->q != NULL) &&
521                 (rsa->dmp1 != NULL) &&
522                 (rsa->dmq1 != NULL) &&
523                 (rsa->iqmp != NULL)) )
524                 {
525                 if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
526                 }
527         else
528                 {
529                 BIGNUM local_d;
530                 BIGNUM *d = NULL;
531                 
532                 if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
533                         {
534                         d = &local_d;
535                         BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
536                         }
537                 else
538                         d = rsa->d;
539
540                 MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
541                 if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
542                                 rsa->_method_mod_n))
543                   goto err;
544                 }
545
546         if (blinding)
547                 if (!rsa_blinding_invert(blinding, local_blinding, ret, br, ctx))
548                         goto err;
549
550         p=buf;
551         j=BN_bn2bin(ret,p); /* j is only used with no-padding mode */
552
553         switch (padding)
554                 {
555         case RSA_PKCS1_PADDING:
556                 r=RSA_padding_check_PKCS1_type_2(to,num,buf,j,num);
557                 break;
558 #ifndef OPENSSL_NO_SHA
559         case RSA_PKCS1_OAEP_PADDING:
560                 r=RSA_padding_check_PKCS1_OAEP(to,num,buf,j,num,NULL,0);
561                 break;
562 #endif
563         case RSA_SSLV23_PADDING:
564                 r=RSA_padding_check_SSLv23(to,num,buf,j,num);
565                 break;
566         case RSA_NO_PADDING:
567                 r=RSA_padding_check_none(to,num,buf,j,num);
568                 break;
569         default:
570                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
571                 goto err;
572                 }
573         if (r < 0)
574                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
575
576 err:
577         if (ctx != NULL)
578                 {
579                 BN_CTX_end(ctx);
580                 BN_CTX_free(ctx);
581                 }
582         if (buf != NULL)
583                 {
584                 OPENSSL_cleanse(buf,num);
585                 OPENSSL_free(buf);
586                 }
587         return(r);
588         }
589
590 /* signature verification */
591 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
592              unsigned char *to, RSA *rsa, int padding)
593         {
594         BIGNUM *f,*ret;
595         int i,num=0,r= -1;
596         unsigned char *p;
597         unsigned char *buf=NULL;
598         BN_CTX *ctx=NULL;
599
600         if((ctx = BN_CTX_new()) == NULL) goto err;
601         BN_CTX_start(ctx);
602         f = BN_CTX_get(ctx);
603         ret = BN_CTX_get(ctx);
604         num=BN_num_bytes(rsa->n);
605         buf = OPENSSL_malloc(num);
606         if(!f || !ret || !buf)
607                 {
608                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
609                 goto err;
610                 }
611
612         /* This check was for equality but PGP does evil things
613          * and chops off the top '0' bytes */
614         if (flen > num)
615                 {
616                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
617                 goto err;
618                 }
619
620         if (BN_bin2bn(from,flen,f) == NULL) goto err;
621
622         if (BN_ucmp(f, rsa->n) >= 0)
623                 {
624                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
625                 goto err;
626                 }
627
628         MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
629
630         if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,
631                 rsa->_method_mod_n)) goto err;
632
633         if ((padding == RSA_X931_PADDING) && ((ret->d[0] & 0xf) != 12))
634                 BN_sub(ret, rsa->n, ret);
635
636         p=buf;
637         i=BN_bn2bin(ret,p);
638
639         switch (padding)
640                 {
641         case RSA_PKCS1_PADDING:
642                 r=RSA_padding_check_PKCS1_type_1(to,num,buf,i,num);
643                 /* Generally signatures should be at least 2/3 padding, though
644                    this isn't possible for really short keys and some standard
645                    signature schemes, so don't check if the unpadded data is
646                    small. */
647                 if(r > 42 && 3*8*r >= BN_num_bits(rsa->n))
648                         {
649                         RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_PKCS1_PADDING_TOO_SHORT);
650                         goto err;
651                         }
652                 break;
653         case RSA_X931_PADDING:
654                 r=RSA_padding_check_X931(to,num,buf,i,num);
655                 break;
656         case RSA_NO_PADDING:
657                 r=RSA_padding_check_none(to,num,buf,i,num);
658                 break;
659         default:
660                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
661                 goto err;
662                 }
663         if (r < 0)
664                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
665
666 err:
667         if (ctx != NULL)
668                 {
669                 BN_CTX_end(ctx);
670                 BN_CTX_free(ctx);
671                 }
672         if (buf != NULL)
673                 {
674                 OPENSSL_cleanse(buf,num);
675                 OPENSSL_free(buf);
676                 }
677         return(r);
678         }
679
680 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
681         {
682         BIGNUM *r1,*m1,*vrfy;
683         BIGNUM local_dmp1, local_dmq1;
684         BIGNUM *dmp1, *dmq1;
685         int ret=0;
686
687         BN_CTX_start(ctx);
688         r1 = BN_CTX_get(ctx);
689         m1 = BN_CTX_get(ctx);
690         vrfy = BN_CTX_get(ctx);
691
692         MONT_HELPER(rsa, ctx, p, rsa->flags & RSA_FLAG_CACHE_PRIVATE, goto err);
693         MONT_HELPER(rsa, ctx, q, rsa->flags & RSA_FLAG_CACHE_PRIVATE, goto err);
694         MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
695
696         if (!BN_mod(r1,I,rsa->q,ctx)) goto err;
697         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
698                 {
699                 dmq1 = &local_dmq1;
700                 BN_with_flags(dmq1, rsa->dmq1, BN_FLG_EXP_CONSTTIME);
701                 }
702         else
703                 dmq1 = rsa->dmq1;
704         if (!rsa->meth->bn_mod_exp(m1,r1,dmq1,rsa->q,ctx,
705                 rsa->_method_mod_q)) goto err;
706
707         if (!BN_mod(r1,I,rsa->p,ctx)) goto err;
708         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
709                 {
710                 dmp1 = &local_dmp1;
711                 BN_with_flags(dmp1, rsa->dmp1, BN_FLG_EXP_CONSTTIME);
712                 }
713         else
714                 dmp1 = rsa->dmp1;
715         if (!rsa->meth->bn_mod_exp(r0,r1,dmp1,rsa->p,ctx,
716                 rsa->_method_mod_p)) goto err;
717
718         if (!BN_sub(r0,r0,m1)) goto err;
719         /* This will help stop the size of r0 increasing, which does
720          * affect the multiply if it optimised for a power of 2 size */
721         if (BN_is_negative(r0))
722                 if (!BN_add(r0,r0,rsa->p)) goto err;
723
724         if (!BN_mul(r1,r0,rsa->iqmp,ctx)) goto err;
725         if (!BN_mod(r0,r1,rsa->p,ctx)) goto err;
726         /* If p < q it is occasionally possible for the correction of
727          * adding 'p' if r0 is negative above to leave the result still
728          * negative. This can break the private key operations: the following
729          * second correction should *always* correct this rare occurrence.
730          * This will *never* happen with OpenSSL generated keys because
731          * they ensure p > q [steve]
732          */
733         if (BN_is_negative(r0))
734                 if (!BN_add(r0,r0,rsa->p)) goto err;
735         if (!BN_mul(r1,r0,rsa->q,ctx)) goto err;
736         if (!BN_add(r0,r1,m1)) goto err;
737
738         if (rsa->e && rsa->n)
739                 {
740                 if (!rsa->meth->bn_mod_exp(vrfy,r0,rsa->e,rsa->n,ctx,rsa->_method_mod_n)) goto err;
741                 /* If 'I' was greater than (or equal to) rsa->n, the operation
742                  * will be equivalent to using 'I mod n'. However, the result of
743                  * the verify will *always* be less than 'n' so we don't check
744                  * for absolute equality, just congruency. */
745                 if (!BN_sub(vrfy, vrfy, I)) goto err;
746                 if (!BN_mod(vrfy, vrfy, rsa->n, ctx)) goto err;
747                 if (BN_is_negative(vrfy))
748                         if (!BN_add(vrfy, vrfy, rsa->n)) goto err;
749                 if (!BN_is_zero(vrfy))
750                         {
751                         /* 'I' and 'vrfy' aren't congruent mod n. Don't leak
752                          * miscalculated CRT output, just do a raw (slower)
753                          * mod_exp and return that instead. */
754
755                         BIGNUM local_d;
756                         BIGNUM *d = NULL;
757                 
758                         if (!(rsa->flags & RSA_FLAG_NO_EXP_CONSTTIME))
759                                 {
760                                 d = &local_d;
761                                 BN_with_flags(d, rsa->d, BN_FLG_EXP_CONSTTIME);
762                                 }
763                         else
764                                 d = rsa->d;
765                         if (!rsa->meth->bn_mod_exp(r0,I,d,rsa->n,ctx,
766                                                    rsa->_method_mod_n)) goto err;
767                         }
768                 }
769         ret=1;
770 err:
771         BN_CTX_end(ctx);
772         return(ret);
773         }
774
775 static int RSA_eay_init(RSA *rsa)
776         {
777         rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
778         return(1);
779         }
780
781 static int RSA_eay_finish(RSA *rsa)
782         {
783         if (rsa->_method_mod_n != NULL)
784                 BN_MONT_CTX_free(rsa->_method_mod_n);
785         if (rsa->_method_mod_p != NULL)
786                 BN_MONT_CTX_free(rsa->_method_mod_p);
787         if (rsa->_method_mod_q != NULL)
788                 BN_MONT_CTX_free(rsa->_method_mod_q);
789         return(1);
790         }
791
792 #endif