We cache a montgomery form for 'n' if the PUBLIC flag is set, not PRIVATE.
[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 #include <stdio.h>
60 #include "cryptlib.h"
61 #include <openssl/bn.h>
62 #include <openssl/rsa.h>
63 #include <openssl/rand.h>
64 #ifndef OPENSSL_NO_ENGINE
65 #include <openssl/engine.h>
66 #endif
67
68 #ifndef RSA_NULL
69
70 static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
71                 unsigned char *to, RSA *rsa,int padding);
72 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
73                 unsigned char *to, RSA *rsa,int padding);
74 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
75                 unsigned char *to, RSA *rsa,int padding);
76 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
77                 unsigned char *to, RSA *rsa,int padding);
78 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *i, RSA *rsa);
79 static int RSA_eay_init(RSA *rsa);
80 static int RSA_eay_finish(RSA *rsa);
81 static RSA_METHOD rsa_pkcs1_eay_meth={
82         "Eric Young's PKCS#1 RSA",
83         RSA_eay_public_encrypt,
84         RSA_eay_public_decrypt, /* signature verification */
85         RSA_eay_private_encrypt, /* signing */
86         RSA_eay_private_decrypt,
87         RSA_eay_mod_exp,
88         BN_mod_exp_mont, /* XXX probably we should not use Montgomery if  e == 3 */
89         RSA_eay_init,
90         RSA_eay_finish,
91         0, /* flags */
92         NULL,
93         0, /* rsa_sign */
94         0, /* rsa_verify */
95         NULL /* rsa_keygen */
96         };
97
98 const RSA_METHOD *RSA_PKCS1_SSLeay(void)
99         {
100         return(&rsa_pkcs1_eay_meth);
101         }
102
103 /* Static helper to reduce oodles of code duplication. As a slight
104  * optimisation, the "MONT_HELPER() macro must be used as front-end to this
105  * function, to prevent unnecessary function calls - there is an initial test
106  * that is performed by the macro-generated code. */
107 static int rsa_eay_mont_helper(BN_MONT_CTX **ptr, const BIGNUM *modulus, BN_CTX *ctx)
108         {
109         BN_MONT_CTX *bn_mont_ctx;
110         if((bn_mont_ctx = BN_MONT_CTX_new()) == NULL)
111                 return 0;
112         if(!BN_MONT_CTX_set(bn_mont_ctx, modulus, ctx))
113                 {
114                 BN_MONT_CTX_free(bn_mont_ctx);
115                 return 0;
116                 }
117         if (*ptr == NULL) /* other thread may have finished first */
118                 {
119                 CRYPTO_w_lock(CRYPTO_LOCK_RSA);
120                 if (*ptr == NULL) /* check again in the lock to stop races */
121                         {
122                         *ptr = bn_mont_ctx;
123                         bn_mont_ctx = NULL;
124                         }
125                 CRYPTO_w_unlock(CRYPTO_LOCK_RSA);
126                 }
127         if (bn_mont_ctx)
128                 BN_MONT_CTX_free(bn_mont_ctx);
129         return 1;
130         }
131 /* Usage example;
132  *    MONT_HELPER(rsa, bn_ctx, p, rsa->flags & RSA_FLAG_CACHE_PRIVATE, goto err);
133  */
134 #define MONT_HELPER(rsa, ctx, m, pre_cond, err_instr) \
135         if((pre_cond) && ((rsa)->_method_mod_##m == NULL) && \
136                         !rsa_eay_mont_helper(&((rsa)->_method_mod_##m), \
137                                 (rsa)->m, (ctx))) \
138                 err_instr
139
140 static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
141              unsigned char *to, RSA *rsa, int padding)
142         {
143         BIGNUM f,ret;
144         int i,j,k,num=0,r= -1;
145         unsigned char *buf=NULL;
146         BN_CTX *ctx=NULL;
147
148         BN_init(&f);
149         BN_init(&ret);
150         if ((ctx=BN_CTX_new()) == NULL) goto err;
151         num=BN_num_bytes(rsa->n);
152         if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
153                 {
154                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,ERR_R_MALLOC_FAILURE);
155                 goto err;
156                 }
157
158         switch (padding)
159                 {
160         case RSA_PKCS1_PADDING:
161                 i=RSA_padding_add_PKCS1_type_2(buf,num,from,flen);
162                 break;
163 #ifndef OPENSSL_NO_SHA
164         case RSA_PKCS1_OAEP_PADDING:
165                 i=RSA_padding_add_PKCS1_OAEP(buf,num,from,flen,NULL,0);
166                 break;
167 #endif
168         case RSA_SSLV23_PADDING:
169                 i=RSA_padding_add_SSLv23(buf,num,from,flen);
170                 break;
171         case RSA_NO_PADDING:
172                 i=RSA_padding_add_none(buf,num,from,flen);
173                 break;
174         default:
175                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
176                 goto err;
177                 }
178         if (i <= 0) goto err;
179
180         if (BN_bin2bn(buf,num,&f) == NULL) goto err;
181         
182         if (BN_ucmp(&f, rsa->n) >= 0)
183                 {       
184                 /* usually the padding functions would catch this */
185                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
186                 goto err;
187                 }
188
189         MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
190
191         if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->e,rsa->n,ctx,
192                 rsa->_method_mod_n)) goto err;
193
194         /* put in leading 0 bytes if the number is less than the
195          * length of the modulus */
196         j=BN_num_bytes(&ret);
197         i=BN_bn2bin(&ret,&(to[num-j]));
198         for (k=0; k<(num-i); k++)
199                 to[k]=0;
200
201         r=num;
202 err:
203         if (ctx != NULL) BN_CTX_free(ctx);
204         BN_clear_free(&f);
205         BN_clear_free(&ret);
206         if (buf != NULL) 
207                 {
208                 OPENSSL_cleanse(buf,num);
209                 OPENSSL_free(buf);
210                 }
211         return(r);
212         }
213
214 /* signing */
215 static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
216              unsigned char *to, RSA *rsa, int padding)
217         {
218         BIGNUM f,ret;
219         int i,j,k,num=0,r= -1;
220         unsigned char *buf=NULL;
221         BN_CTX *ctx=NULL;
222
223         BN_init(&f);
224         BN_init(&ret);
225
226         if ((ctx=BN_CTX_new()) == NULL) goto err;
227         num=BN_num_bytes(rsa->n);
228         if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
229                 {
230                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
231                 goto err;
232                 }
233
234         switch (padding)
235                 {
236         case RSA_PKCS1_PADDING:
237                 i=RSA_padding_add_PKCS1_type_1(buf,num,from,flen);
238                 break;
239         case RSA_NO_PADDING:
240                 i=RSA_padding_add_none(buf,num,from,flen);
241                 break;
242         case RSA_SSLV23_PADDING:
243         default:
244                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
245                 goto err;
246                 }
247         if (i <= 0) goto err;
248
249         if (BN_bin2bn(buf,num,&f) == NULL) goto err;
250         
251         if (BN_ucmp(&f, rsa->n) >= 0)
252                 {       
253                 /* usually the padding functions would catch this */
254                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
255                 goto err;
256                 }
257
258         if ((rsa->flags & RSA_FLAG_BLINDING) && (rsa->blinding == NULL))
259                 RSA_blinding_on(rsa,ctx);
260         if (rsa->flags & RSA_FLAG_BLINDING)
261                 if (!BN_BLINDING_convert(&f,rsa->blinding,ctx)) goto err;
262
263         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
264                 ((rsa->p != NULL) &&
265                 (rsa->q != NULL) &&
266                 (rsa->dmp1 != NULL) &&
267                 (rsa->dmq1 != NULL) &&
268                 (rsa->iqmp != NULL)) )
269                 { if (!rsa->meth->rsa_mod_exp(&ret,&f,rsa)) goto err; }
270         else
271                 {
272                 MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
273                 if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->d,rsa->n,ctx,
274                                 rsa->_method_mod_n)) goto err;
275                 }
276
277         if (rsa->flags & RSA_FLAG_BLINDING)
278                 if (!BN_BLINDING_invert(&ret,rsa->blinding,ctx)) goto err;
279
280         /* put in leading 0 bytes if the number is less than the
281          * length of the modulus */
282         j=BN_num_bytes(&ret);
283         i=BN_bn2bin(&ret,&(to[num-j]));
284         for (k=0; k<(num-i); k++)
285                 to[k]=0;
286
287         r=num;
288 err:
289         if (ctx != NULL) BN_CTX_free(ctx);
290         BN_clear_free(&ret);
291         BN_clear_free(&f);
292         if (buf != NULL)
293                 {
294                 OPENSSL_cleanse(buf,num);
295                 OPENSSL_free(buf);
296                 }
297         return(r);
298         }
299
300 static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
301              unsigned char *to, RSA *rsa, int padding)
302         {
303         BIGNUM f,ret;
304         int j,num=0,r= -1;
305         unsigned char *p;
306         unsigned char *buf=NULL;
307         BN_CTX *ctx=NULL;
308
309         BN_init(&f);
310         BN_init(&ret);
311         ctx=BN_CTX_new();
312         if (ctx == NULL) goto err;
313
314         num=BN_num_bytes(rsa->n);
315
316         if ((buf=(unsigned char *)OPENSSL_malloc(num)) == NULL)
317                 {
318                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
319                 goto err;
320                 }
321
322         /* This check was for equality but PGP does evil things
323          * and chops off the top '0' bytes */
324         if (flen > num)
325                 {
326                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
327                 goto err;
328                 }
329
330         /* make data into a big number */
331         if (BN_bin2bn(from,(int)flen,&f) == NULL) goto err;
332
333         if (BN_ucmp(&f, rsa->n) >= 0)
334                 {
335                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
336                 goto err;
337                 }
338
339         if ((rsa->flags & RSA_FLAG_BLINDING) && (rsa->blinding == NULL))
340                 RSA_blinding_on(rsa,ctx);
341         if (rsa->flags & RSA_FLAG_BLINDING)
342                 if (!BN_BLINDING_convert(&f,rsa->blinding,ctx)) goto err;
343
344         /* do the decrypt */
345         if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
346                 ((rsa->p != NULL) &&
347                 (rsa->q != NULL) &&
348                 (rsa->dmp1 != NULL) &&
349                 (rsa->dmq1 != NULL) &&
350                 (rsa->iqmp != NULL)) )
351                 { if (!rsa->meth->rsa_mod_exp(&ret,&f,rsa)) goto err; }
352         else
353                 {
354                 MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
355                 if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->d,rsa->n,ctx,
356                                 rsa->_method_mod_n))
357                         goto err;
358                 }
359
360         if (rsa->flags & RSA_FLAG_BLINDING)
361                 if (!BN_BLINDING_invert(&ret,rsa->blinding,ctx)) goto err;
362
363         p=buf;
364         j=BN_bn2bin(&ret,p); /* j is only used with no-padding mode */
365
366         switch (padding)
367                 {
368         case RSA_PKCS1_PADDING:
369                 r=RSA_padding_check_PKCS1_type_2(to,num,buf,j,num);
370                 break;
371 #ifndef OPENSSL_NO_SHA
372         case RSA_PKCS1_OAEP_PADDING:
373                 r=RSA_padding_check_PKCS1_OAEP(to,num,buf,j,num,NULL,0);
374                 break;
375 #endif
376         case RSA_SSLV23_PADDING:
377                 r=RSA_padding_check_SSLv23(to,num,buf,j,num);
378                 break;
379         case RSA_NO_PADDING:
380                 r=RSA_padding_check_none(to,num,buf,j,num);
381                 break;
382         default:
383                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
384                 goto err;
385                 }
386         if (r < 0)
387                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
388
389 err:
390         if (ctx != NULL) BN_CTX_free(ctx);
391         BN_clear_free(&f);
392         BN_clear_free(&ret);
393         if (buf != NULL)
394                 {
395                 OPENSSL_cleanse(buf,num);
396                 OPENSSL_free(buf);
397                 }
398         return(r);
399         }
400
401 /* signature verification */
402 static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
403              unsigned char *to, RSA *rsa, int padding)
404         {
405         BIGNUM f,ret;
406         int i,num=0,r= -1;
407         unsigned char *p;
408         unsigned char *buf=NULL;
409         BN_CTX *ctx=NULL;
410
411         BN_init(&f);
412         BN_init(&ret);
413         ctx=BN_CTX_new();
414         if (ctx == NULL) goto err;
415
416         num=BN_num_bytes(rsa->n);
417         buf=(unsigned char *)OPENSSL_malloc(num);
418         if (buf == NULL)
419                 {
420                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
421                 goto err;
422                 }
423
424         /* This check was for equality but PGP does evil things
425          * and chops off the top '0' bytes */
426         if (flen > num)
427                 {
428                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
429                 goto err;
430                 }
431
432         if (BN_bin2bn(from,flen,&f) == NULL) goto err;
433
434         if (BN_ucmp(&f, rsa->n) >= 0)
435                 {
436                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
437                 goto err;
438                 }
439
440         MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
441
442         if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->e,rsa->n,ctx,
443                 rsa->_method_mod_n)) goto err;
444
445         p=buf;
446         i=BN_bn2bin(&ret,p);
447
448         switch (padding)
449                 {
450         case RSA_PKCS1_PADDING:
451                 r=RSA_padding_check_PKCS1_type_1(to,num,buf,i,num);
452                 break;
453         case RSA_NO_PADDING:
454                 r=RSA_padding_check_none(to,num,buf,i,num);
455                 break;
456         default:
457                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
458                 goto err;
459                 }
460         if (r < 0)
461                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
462
463 err:
464         if (ctx != NULL) BN_CTX_free(ctx);
465         BN_clear_free(&f);
466         BN_clear_free(&ret);
467         if (buf != NULL)
468                 {
469                 OPENSSL_cleanse(buf,num);
470                 OPENSSL_free(buf);
471                 }
472         return(r);
473         }
474
475 static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
476         {
477         BIGNUM r1,m1,vrfy;
478         int ret=0;
479         BN_CTX *ctx;
480
481         BN_init(&m1);
482         BN_init(&r1);
483         BN_init(&vrfy);
484         if ((ctx=BN_CTX_new()) == NULL) goto err;
485
486         MONT_HELPER(rsa, ctx, p, rsa->flags & RSA_FLAG_CACHE_PRIVATE, goto err);
487         MONT_HELPER(rsa, ctx, q, rsa->flags & RSA_FLAG_CACHE_PRIVATE, goto err);
488         MONT_HELPER(rsa, ctx, n, rsa->flags & RSA_FLAG_CACHE_PUBLIC, goto err);
489
490         if (!BN_mod(&r1,I,rsa->q,ctx)) goto err;
491         if (!rsa->meth->bn_mod_exp(&m1,&r1,rsa->dmq1,rsa->q,ctx,
492                 rsa->_method_mod_q)) goto err;
493
494         if (!BN_mod(&r1,I,rsa->p,ctx)) goto err;
495         if (!rsa->meth->bn_mod_exp(r0,&r1,rsa->dmp1,rsa->p,ctx,
496                 rsa->_method_mod_p)) goto err;
497
498         if (!BN_sub(r0,r0,&m1)) goto err;
499         /* This will help stop the size of r0 increasing, which does
500          * affect the multiply if it optimised for a power of 2 size */
501         if (BN_get_sign(r0))
502                 if (!BN_add(r0,r0,rsa->p)) goto err;
503
504         if (!BN_mul(&r1,r0,rsa->iqmp,ctx)) goto err;
505         if (!BN_mod(r0,&r1,rsa->p,ctx)) goto err;
506         /* If p < q it is occasionally possible for the correction of
507          * adding 'p' if r0 is negative above to leave the result still
508          * negative. This can break the private key operations: the following
509          * second correction should *always* correct this rare occurrence.
510          * This will *never* happen with OpenSSL generated keys because
511          * they ensure p > q [steve]
512          */
513         if (BN_get_sign(r0))
514                 if (!BN_add(r0,r0,rsa->p)) goto err;
515         if (!BN_mul(&r1,r0,rsa->q,ctx)) goto err;
516         if (!BN_add(r0,&r1,&m1)) goto err;
517
518         if (rsa->e && rsa->n)
519                 {
520                 if (!rsa->meth->bn_mod_exp(&vrfy,r0,rsa->e,rsa->n,ctx,rsa->_method_mod_n)) goto err;
521                 /* If 'I' was greater than (or equal to) rsa->n, the operation
522                  * will be equivalent to using 'I mod n'. However, the result of
523                  * the verify will *always* be less than 'n' so we don't check
524                  * for absolute equality, just congruency. */
525                 if (!BN_sub(&vrfy, &vrfy, I)) goto err;
526                 if (!BN_mod(&vrfy, &vrfy, rsa->n, ctx)) goto err;
527                 if (BN_get_sign(&vrfy))
528                         if (!BN_add(&vrfy, &vrfy, rsa->n)) goto err;
529                 if (!BN_is_zero(&vrfy))
530                         /* 'I' and 'vrfy' aren't congruent mod n. Don't leak
531                          * miscalculated CRT output, just do a raw (slower)
532                          * mod_exp and return that instead. */
533                         if (!rsa->meth->bn_mod_exp(r0,I,rsa->d,rsa->n,ctx,
534                                         rsa->_method_mod_n)) goto err;
535                 }
536         ret=1;
537 err:
538         BN_clear_free(&m1);
539         BN_clear_free(&r1);
540         BN_clear_free(&vrfy);
541         BN_CTX_free(ctx);
542         return(ret);
543         }
544
545 static int RSA_eay_init(RSA *rsa)
546         {
547         rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
548         return(1);
549         }
550
551 static int RSA_eay_finish(RSA *rsa)
552         {
553         if (rsa->_method_mod_n != NULL)
554                 BN_MONT_CTX_free(rsa->_method_mod_n);
555         if (rsa->_method_mod_p != NULL)
556                 BN_MONT_CTX_free(rsa->_method_mod_p);
557         if (rsa->_method_mod_q != NULL)
558                 BN_MONT_CTX_free(rsa->_method_mod_q);
559         return(1);
560         }
561
562 #endif