Implement internally opaque bn access from rsa
[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 "internal/bn_int.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 *d = NULL, *local_d = NULL;
437                 
438                 if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
439                         {
440                         local_d = d = BN_new();
441                         if(!d)
442                                 {
443                                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
444                                 goto err;
445                                 }
446                         BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
447                         }
448                 else
449                         d= rsa->d;
450
451                 if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
452                         if(!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
453                                 {
454                                 if(local_d) BN_free(local_d);
455                                 goto err;
456                                 }
457
458                 if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
459                                 rsa->_method_mod_n))
460                         {
461                         if(local_d) BN_free(local_d);
462                         goto err;
463                         }
464                 if(local_d) BN_free(local_d);
465                 }
466
467         if (blinding)
468                 if (!rsa_blinding_invert(blinding, ret, unblind, ctx))
469                         goto err;
470
471         if (padding == RSA_X931_PADDING)
472                 {
473                 BN_sub(f, rsa->n, ret);
474                 if (BN_cmp(ret, f) > 0)
475                         res = f;
476                 else
477                         res = ret;
478                 }
479         else
480                 res = ret;
481
482         /* put in leading 0 bytes if the number is less than the
483          * length of the modulus */
484         j=BN_num_bytes(res);
485         i=BN_bn2bin(res,&(to[num-j]));
486         for (k=0; k<(num-i); k++)
487                 to[k]=0;
488
489         r=num;
490 err:
491         if (ctx != NULL)
492                 {
493                 BN_CTX_end(ctx);
494                 BN_CTX_free(ctx);
495                 }
496         if (buf != NULL)
497                 {
498                 OPENSSL_cleanse(buf,num);
499                 OPENSSL_free(buf);
500                 }
501         return(r);
502         }
503
504 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
505              unsigned char *to, RSA *rsa, int padding)
506         {
507         BIGNUM *f, *ret;
508         int j,num=0,r= -1;
509         unsigned char *p;
510         unsigned char *buf=NULL;
511         BN_CTX *ctx=NULL;
512         int local_blinding = 0;
513         /* Used only if the blinding structure is shared. A non-NULL unblind
514          * instructs rsa_blinding_convert() and rsa_blinding_invert() to store
515          * the unblinding factor outside the blinding structure. */
516         BIGNUM *unblind = NULL;
517         BN_BLINDING *blinding = NULL;
518
519         if((ctx = BN_CTX_new()) == NULL) goto err;
520         BN_CTX_start(ctx);
521         f   = BN_CTX_get(ctx);
522         ret = BN_CTX_get(ctx);
523         num = BN_num_bytes(rsa->n);
524         buf = OPENSSL_malloc(num);
525         if(!f || !ret || !buf)
526                 {
527                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
528                 goto err;
529                 }
530
531         /* This check was for equality but PGP does evil things
532          * and chops off the top '0' bytes */
533         if (flen > num)
534                 {
535                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
536                 goto err;
537                 }
538
539         /* make data into a big number */
540         if (BN_bin2bn(from,(int)flen,f) == NULL) goto err;
541
542         if (BN_ucmp(f, rsa->n) >= 0)
543                 {
544                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
545                 goto err;
546                 }
547
548         if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
549                 {
550                 blinding = rsa_get_blinding(rsa, &local_blinding, ctx);
551                 if (blinding == NULL)
552                         {
553                         RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT, ERR_R_INTERNAL_ERROR);
554                         goto err;
555                         }
556                 }
557         
558         if (blinding != NULL)
559                 {
560                 if (!local_blinding && ((unblind = BN_CTX_get(ctx)) == NULL))
561                         {
562                         RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
563                         goto err;
564                         }
565                 if (!rsa_blinding_convert(blinding, f, unblind, ctx))
566                         goto err;
567                 }
568
569         /* do the decrypt */
570         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
571                 ((rsa->p != NULL) &&
572                 (rsa->q != NULL) &&
573                 (rsa->dmp1 != NULL) &&
574                 (rsa->dmq1 != NULL) &&
575                 (rsa->iqmp != NULL)) )
576                 {
577                 if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
578                 }
579         else
580                 {
581                 BIGNUM *d = NULL, *local_d = NULL;
582                 
583                 if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
584                         {
585                         local_d = d = BN_new();
586                         if(!d)
587                                 {
588                                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
589                                 goto err;
590                                 }
591                         BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
592                         }
593                 else
594                         d = rsa->d;
595
596                 if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
597                         if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
598                                 {
599                                 if(local_d) BN_free(local_d);
600                                 goto err;
601                                 }
602                 if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
603                                 rsa->_method_mod_n))
604                         {
605                         if(local_d) BN_free(local_d);
606                         goto err;
607                         }
608                 if(local_d) BN_free(local_d);
609                 }
610
611         if (blinding)
612                 if (!rsa_blinding_invert(blinding, ret, unblind, ctx))
613                         goto err;
614
615         p=buf;
616         j=BN_bn2bin(ret,p); /* j is only used with no-padding mode */
617
618         switch (padding)
619                 {
620         case RSA_PKCS1_PADDING:
621                 r=RSA_padding_check_PKCS1_type_2(to,num,buf,j,num);
622                 break;
623 #ifndef OPENSSL_NO_SHA
624         case RSA_PKCS1_OAEP_PADDING:
625                 r=RSA_padding_check_PKCS1_OAEP(to,num,buf,j,num,NULL,0);
626                 break;
627 #endif
628         case RSA_SSLV23_PADDING:
629                 r=RSA_padding_check_SSLv23(to,num,buf,j,num);
630                 break;
631         case RSA_NO_PADDING:
632                 r=RSA_padding_check_none(to,num,buf,j,num);
633                 break;
634         default:
635                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
636                 goto err;
637                 }
638         if (r < 0)
639                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
640
641 err:
642         if (ctx != NULL)
643                 {
644                 BN_CTX_end(ctx);
645                 BN_CTX_free(ctx);
646                 }
647         if (buf != NULL)
648                 {
649                 OPENSSL_cleanse(buf,num);
650                 OPENSSL_free(buf);
651                 }
652         return(r);
653         }
654
655 /* signature verification */
656 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
657              unsigned char *to, RSA *rsa, int padding)
658         {
659         BIGNUM *f,*ret;
660         int i,num=0,r= -1;
661         unsigned char *p;
662         unsigned char *buf=NULL;
663         BN_CTX *ctx=NULL;
664
665         if (BN_num_bits(rsa->n) > OPENSSL_RSA_MAX_MODULUS_BITS)
666                 {
667                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_MODULUS_TOO_LARGE);
668                 return -1;
669                 }
670
671         if (BN_ucmp(rsa->n, rsa->e) <= 0)
672                 {
673                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_BAD_E_VALUE);
674                 return -1;
675                 }
676
677         /* for large moduli, enforce exponent limit */
678         if (BN_num_bits(rsa->n) > OPENSSL_RSA_SMALL_MODULUS_BITS)
679                 {
680                 if (BN_num_bits(rsa->e) > OPENSSL_RSA_MAX_PUBEXP_BITS)
681                         {
682                         RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_BAD_E_VALUE);
683                         return -1;
684                         }
685                 }
686         
687         if((ctx = BN_CTX_new()) == NULL) goto err;
688         BN_CTX_start(ctx);
689         f = BN_CTX_get(ctx);
690         ret = BN_CTX_get(ctx);
691         num=BN_num_bytes(rsa->n);
692         buf = OPENSSL_malloc(num);
693         if(!f || !ret || !buf)
694                 {
695                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
696                 goto err;
697                 }
698
699         /* This check was for equality but PGP does evil things
700          * and chops off the top '0' bytes */
701         if (flen > num)
702                 {
703                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
704                 goto err;
705                 }
706
707         if (BN_bin2bn(from,flen,f) == NULL) goto err;
708
709         if (BN_ucmp(f, rsa->n) >= 0)
710                 {
711                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
712                 goto err;
713                 }
714
715         if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
716                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
717                         goto err;
718
719         if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,
720                 rsa->_method_mod_n)) goto err;
721
722         if ((padding == RSA_X931_PADDING) && ((bn_get_words(ret)[0] & 0xf) != 12))
723                 if (!BN_sub(ret, rsa->n, ret)) goto err;
724
725         p=buf;
726         i=BN_bn2bin(ret,p);
727
728         switch (padding)
729                 {
730         case RSA_PKCS1_PADDING:
731                 r=RSA_padding_check_PKCS1_type_1(to,num,buf,i,num);
732                 break;
733         case RSA_X931_PADDING:
734                 r=RSA_padding_check_X931(to,num,buf,i,num);
735                 break;
736         case RSA_NO_PADDING:
737                 r=RSA_padding_check_none(to,num,buf,i,num);
738                 break;
739         default:
740                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
741                 goto err;
742                 }
743         if (r < 0)
744                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
745
746 err:
747         if (ctx != NULL)
748                 {
749                 BN_CTX_end(ctx);
750                 BN_CTX_free(ctx);
751                 }
752         if (buf != NULL)
753                 {
754                 OPENSSL_cleanse(buf,num);
755                 OPENSSL_free(buf);
756                 }
757         return(r);
758         }
759
760 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
761         {
762         BIGNUM *r1,*m1,*vrfy;
763         BIGNUM *local_dmp1, *local_dmq1, *local_c, *local_r1;
764         BIGNUM *dmp1,*dmq1,*c,*pr1;
765         int ret=0;
766
767
768         local_dmp1 = BN_new();
769         local_dmq1 = BN_new();
770         local_c = BN_new();
771         local_r1 = BN_new();
772         if(!local_dmp1 || !local_dmq1 || !local_c || !local_r1)
773                 goto err;
774
775         BN_CTX_start(ctx);
776         r1 = BN_CTX_get(ctx);
777         m1 = BN_CTX_get(ctx);
778         vrfy = BN_CTX_get(ctx);
779
780         {
781                 BIGNUM *local_p = NULL, *local_q = NULL;
782                 BIGNUM *p = NULL, *q = NULL;
783
784                 /* Make sure BN_mod_inverse in Montgomery intialization uses the
785                  * BN_FLG_CONSTTIME flag (unless RSA_FLAG_NO_CONSTTIME is set)
786                  */
787                 if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
788                         {
789                         local_p = p = BN_new();
790                         if(!p) goto err;
791                         BN_with_flags(p, rsa->p, BN_FLG_CONSTTIME);
792
793                         local_q = q = BN_new();
794                         if(!q)
795                                 {
796                                 BN_free(local_p);
797                                 goto err;
798                                 }
799                         BN_with_flags(q, rsa->q, BN_FLG_CONSTTIME);
800                         }
801                 else
802                         {
803                         p = rsa->p;
804                         q = rsa->q;
805                         }
806
807                 if (rsa->flags & RSA_FLAG_CACHE_PRIVATE)
808                         {
809                         if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_p, CRYPTO_LOCK_RSA, p, ctx) || !BN_MONT_CTX_set_locked(&rsa->_method_mod_q, CRYPTO_LOCK_RSA, q, ctx))
810                                 {
811                                 if(local_p) BN_free(local_p);
812                                 if(local_q) BN_free(local_q);
813                                 goto err;
814                                 }
815                         }
816                 if(local_p) BN_free(local_p);
817                 if(local_q) BN_free(local_q);
818         }
819
820         if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
821                 if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
822                         goto err;
823
824         /* compute I mod q */
825         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
826                 {
827                 c = local_c;
828                 BN_with_flags(c, I, BN_FLG_CONSTTIME);
829                 if (!BN_mod(r1,c,rsa->q,ctx)) goto err;
830                 }
831         else
832                 {
833                 if (!BN_mod(r1,I,rsa->q,ctx)) goto err;
834                 }
835
836         /* compute r1^dmq1 mod q */
837         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
838                 {
839                 dmq1 = local_dmq1;
840                 BN_with_flags(dmq1, rsa->dmq1, BN_FLG_CONSTTIME);
841                 }
842         else
843                 dmq1 = rsa->dmq1;
844         if (!rsa->meth->bn_mod_exp(m1,r1,dmq1,rsa->q,ctx,
845                 rsa->_method_mod_q)) goto err;
846
847         /* compute I mod p */
848         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
849                 {
850                 c = local_c;
851                 BN_with_flags(c, I, BN_FLG_CONSTTIME);
852                 if (!BN_mod(r1,c,rsa->p,ctx)) goto err;
853                 }
854         else
855                 {
856                 if (!BN_mod(r1,I,rsa->p,ctx)) goto err;
857                 }
858
859         /* compute r1^dmp1 mod p */
860         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
861                 {
862                 dmp1 = local_dmp1;
863                 BN_with_flags(dmp1, rsa->dmp1, BN_FLG_CONSTTIME);
864                 }
865         else
866                 dmp1 = rsa->dmp1;
867         if (!rsa->meth->bn_mod_exp(r0,r1,dmp1,rsa->p,ctx,
868                 rsa->_method_mod_p)) goto err;
869
870         if (!BN_sub(r0,r0,m1)) goto err;
871         /* This will help stop the size of r0 increasing, which does
872          * affect the multiply if it optimised for a power of 2 size */
873         if (BN_is_negative(r0))
874                 if (!BN_add(r0,r0,rsa->p)) goto err;
875
876         if (!BN_mul(r1,r0,rsa->iqmp,ctx)) goto err;
877
878         /* Turn BN_FLG_CONSTTIME flag on before division operation */
879         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
880                 {
881                 pr1 = local_r1;
882                 BN_with_flags(pr1, r1, BN_FLG_CONSTTIME);
883                 }
884         else
885                 pr1 = r1;
886         if (!BN_mod(r0,pr1,rsa->p,ctx)) goto err;
887
888         /* If p < q it is occasionally possible for the correction of
889          * adding 'p' if r0 is negative above to leave the result still
890          * negative. This can break the private key operations: the following
891          * second correction should *always* correct this rare occurrence.
892          * This will *never* happen with OpenSSL generated keys because
893          * they ensure p > q [steve]
894          */
895         if (BN_is_negative(r0))
896                 if (!BN_add(r0,r0,rsa->p)) goto err;
897         if (!BN_mul(r1,r0,rsa->q,ctx)) goto err;
898         if (!BN_add(r0,r1,m1)) goto err;
899
900         if (rsa->e && rsa->n)
901                 {
902                 if (!rsa->meth->bn_mod_exp(vrfy,r0,rsa->e,rsa->n,ctx,rsa->_method_mod_n)) goto err;
903                 /* If 'I' was greater than (or equal to) rsa->n, the operation
904                  * will be equivalent to using 'I mod n'. However, the result of
905                  * the verify will *always* be less than 'n' so we don't check
906                  * for absolute equality, just congruency. */
907                 if (!BN_sub(vrfy, vrfy, I)) goto err;
908                 if (!BN_mod(vrfy, vrfy, rsa->n, ctx)) goto err;
909                 if (BN_is_negative(vrfy))
910                         if (!BN_add(vrfy, vrfy, rsa->n)) goto err;
911                 if (!BN_is_zero(vrfy))
912                         {
913                         /* 'I' and 'vrfy' aren't congruent mod n. Don't leak
914                          * miscalculated CRT output, just do a raw (slower)
915                          * mod_exp and return that instead. */
916
917                         BIGNUM *local_d = NULL;
918                         BIGNUM *d = NULL;
919                 
920                         if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
921                                 {
922                                 local_d = d = BN_new();
923                                 if(!d) goto err;
924                                 BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
925                                 }
926                         else
927                                 d = rsa->d;
928                         if (!rsa->meth->bn_mod_exp(r0,I,d,rsa->n,ctx,
929                                                    rsa->_method_mod_n))
930                                 {
931                                 if(local_d) BN_free(local_d);
932                                 goto err;
933                                 }
934
935                         if(local_d) BN_free(local_d);
936                         }
937                 }
938         ret=1;
939 err:
940         if(local_dmp1) BN_free(local_dmp1);
941         if(local_dmq1) BN_free(local_dmq1);
942         if(local_c) BN_free(local_c);
943         if(local_r1) BN_free(local_r1);
944         BN_CTX_end(ctx);
945         return(ret);
946         }
947
948 static int RSA_eay_init(RSA *rsa)
949         {
950         rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
951         return(1);
952         }
953
954 static int RSA_eay_finish(RSA *rsa)
955         {
956         if (rsa->_method_mod_n != NULL)
957                 BN_MONT_CTX_free(rsa->_method_mod_n);
958         if (rsa->_method_mod_p != NULL)
959                 BN_MONT_CTX_free(rsa->_method_mod_p);
960         if (rsa->_method_mod_q != NULL)
961                 BN_MONT_CTX_free(rsa->_method_mod_q);
962         return(1);
963         }
964
965 #endif