3ebde4fd9326946f96125a9a0abe9a78c3c6b5af
[openssl.git] / crypto / rsa / rsa_lib.c
1 /* crypto/rsa/rsa_lib.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 <openssl/crypto.h>
61 #include "cryptlib.h"
62 #include <openssl/lhash.h>
63 #include <openssl/bn.h>
64 #include <openssl/rsa.h>
65 #ifndef OPENSSL_NO_ENGINE
66 #include <openssl/engine.h>
67 #endif
68
69 const char *RSA_version="RSA" OPENSSL_VERSION_PTEXT;
70
71 static const RSA_METHOD *default_RSA_meth=NULL;
72
73 RSA *RSA_new(void)
74         {
75         RSA *r=RSA_new_method(NULL);
76
77         return r;
78         }
79
80 void RSA_set_default_method(const RSA_METHOD *meth)
81         {
82         default_RSA_meth = meth;
83         }
84
85 const RSA_METHOD *RSA_get_default_method(void)
86         {
87         if (default_RSA_meth == NULL)
88                 {
89 #ifdef RSA_NULL
90                 default_RSA_meth=RSA_null_method();
91 #else
92 #if 0 /* was: #ifdef RSAref */
93                 default_RSA_meth=RSA_PKCS1_RSAref();
94 #else
95                 default_RSA_meth=RSA_PKCS1_SSLeay();
96 #endif
97 #endif
98                 }
99
100         return default_RSA_meth;
101         }
102
103 const RSA_METHOD *RSA_get_method(const RSA *rsa)
104         {
105         return rsa->meth;
106         }
107
108 int RSA_set_method(RSA *rsa, const RSA_METHOD *meth)
109         {
110         /* NB: The caller is specifically setting a method, so it's not up to us
111          * to deal with which ENGINE it comes from. */
112         const RSA_METHOD *mtmp;
113         mtmp = rsa->meth;
114         if (mtmp->finish) mtmp->finish(rsa);
115 #ifndef OPENSSL_NO_ENGINE
116         if (rsa->engine)
117                 {
118                 ENGINE_finish(rsa->engine);
119                 rsa->engine = NULL;
120                 }
121 #endif
122         rsa->meth = meth;
123         if (meth->init) meth->init(rsa);
124         return 1;
125         }
126
127 RSA *RSA_new_method(ENGINE *engine)
128         {
129         RSA *ret;
130
131         ret=(RSA *)OPENSSL_malloc(sizeof(RSA));
132         if (ret == NULL)
133                 {
134                 RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE);
135                 return NULL;
136                 }
137
138         ret->meth = RSA_get_default_method();
139 #ifndef OPENSSL_NO_ENGINE
140         if (engine)
141                 {
142                 if (!ENGINE_init(engine))
143                         {
144                         RSAerr(RSA_F_RSA_NEW_METHOD, ERR_R_ENGINE_LIB);
145                         OPENSSL_free(ret);
146                         return NULL;
147                         }
148                 ret->engine = engine;
149                 }
150         else
151                 ret->engine = ENGINE_get_default_RSA();
152         if(ret->engine)
153                 {
154                 ret->meth = ENGINE_get_RSA(ret->engine);
155                 if(!ret->meth)
156                         {
157                         RSAerr(RSA_F_RSA_NEW_METHOD,
158                                 ERR_R_ENGINE_LIB);
159                         ENGINE_finish(ret->engine);
160                         OPENSSL_free(ret);
161                         return NULL;
162                         }
163                 }
164 #endif
165
166         ret->pad=0;
167         ret->version=0;
168         ret->n=NULL;
169         ret->e=NULL;
170         ret->d=NULL;
171         ret->p=NULL;
172         ret->q=NULL;
173         ret->dmp1=NULL;
174         ret->dmq1=NULL;
175         ret->iqmp=NULL;
176         ret->references=1;
177         ret->_method_mod_n=NULL;
178         ret->_method_mod_p=NULL;
179         ret->_method_mod_q=NULL;
180         ret->blinding=NULL;
181         ret->bignum_data=NULL;
182         ret->flags=ret->meth->flags;
183         CRYPTO_new_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data);
184         if ((ret->meth->init != NULL) && !ret->meth->init(ret))
185                 {
186 #ifndef OPENSSL_NO_ENGINE
187                 if (ret->engine)
188                         ENGINE_finish(ret->engine);
189 #endif
190                 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data);
191                 OPENSSL_free(ret);
192                 ret=NULL;
193                 }
194         return(ret);
195         }
196
197 void RSA_free(RSA *r)
198         {
199         int i;
200
201         if (r == NULL) return;
202
203         i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_RSA);
204 #ifdef REF_PRINT
205         REF_PRINT("RSA",r);
206 #endif
207         if (i > 0) return;
208 #ifdef REF_CHECK
209         if (i < 0)
210                 {
211                 fprintf(stderr,"RSA_free, bad reference count\n");
212                 abort();
213                 }
214 #endif
215
216         if (r->meth->finish)
217                 r->meth->finish(r);
218 #ifndef OPENSSL_NO_ENGINE
219         if (r->engine)
220                 ENGINE_finish(r->engine);
221 #endif
222
223         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, r, &r->ex_data);
224
225         if (r->n != NULL) BN_clear_free(r->n);
226         if (r->e != NULL) BN_clear_free(r->e);
227         if (r->d != NULL) BN_clear_free(r->d);
228         if (r->p != NULL) BN_clear_free(r->p);
229         if (r->q != NULL) BN_clear_free(r->q);
230         if (r->dmp1 != NULL) BN_clear_free(r->dmp1);
231         if (r->dmq1 != NULL) BN_clear_free(r->dmq1);
232         if (r->iqmp != NULL) BN_clear_free(r->iqmp);
233         if (r->blinding != NULL) BN_BLINDING_free(r->blinding);
234         if (r->bignum_data != NULL) OPENSSL_free_locked(r->bignum_data);
235         OPENSSL_free(r);
236         }
237
238 int RSA_up_ref(RSA *r)
239         {
240         int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_RSA);
241 #ifdef REF_PRINT
242         REF_PRINT("RSA",r);
243 #endif
244 #ifdef REF_CHECK
245         if (i < 2)
246                 {
247                 fprintf(stderr, "RSA_up_ref, bad reference count\n");
248                 abort();
249                 }
250 #endif
251         return ((i > 1) ? 1 : 0);
252         }
253
254 int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
255              CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
256         {
257         return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, argl, argp,
258                                 new_func, dup_func, free_func);
259         }
260
261 int RSA_set_ex_data(RSA *r, int idx, void *arg)
262         {
263         return(CRYPTO_set_ex_data(&r->ex_data,idx,arg));
264         }
265
266 void *RSA_get_ex_data(const RSA *r, int idx)
267         {
268         return(CRYPTO_get_ex_data(&r->ex_data,idx));
269         }
270
271 int RSA_size(const RSA *r)
272         {
273         return(BN_num_bytes(r->n));
274         }
275
276 int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to,
277              RSA *rsa, int padding)
278         {
279         return(rsa->meth->rsa_pub_enc(flen, from, to, rsa, padding));
280         }
281
282 int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to,
283              RSA *rsa, int padding)
284         {
285         return(rsa->meth->rsa_priv_enc(flen, from, to, rsa, padding));
286         }
287
288 int RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to,
289              RSA *rsa, int padding)
290         {
291         return(rsa->meth->rsa_priv_dec(flen, from, to, rsa, padding));
292         }
293
294 int RSA_public_decrypt(int flen, const unsigned char *from, unsigned char *to,
295              RSA *rsa, int padding)
296         {
297         return(rsa->meth->rsa_pub_dec(flen, from, to, rsa, padding));
298         }
299
300 int RSA_flags(const RSA *r)
301         {
302         return((r == NULL)?0:r->meth->flags);
303         }
304
305 void RSA_blinding_off(RSA *rsa)
306         {
307         if (rsa->blinding != NULL)
308                 {
309                 BN_BLINDING_free(rsa->blinding);
310                 rsa->blinding=NULL;
311                 }
312         rsa->flags &= ~RSA_FLAG_BLINDING;
313         rsa->flags |= RSA_FLAG_NO_BLINDING;
314         }
315
316 int RSA_blinding_on(RSA *rsa, BN_CTX *p_ctx)
317         {
318         BIGNUM *A,*Ai;
319         BN_CTX *ctx;
320         int ret=0;
321
322         if (p_ctx == NULL)
323                 {
324                 if ((ctx=BN_CTX_new()) == NULL) goto err;
325                 }
326         else
327                 ctx=p_ctx;
328
329         if (rsa->blinding != NULL)
330                 BN_BLINDING_free(rsa->blinding);
331
332         /* NB: similar code appears in setup_blinding (rsa_eay.c);
333          * this should be placed in a new function of its own, but for reasons
334          * of binary compatibility can't */
335
336         BN_CTX_start(ctx);
337         A = BN_CTX_get(ctx);
338         if ((RAND_status() == 0) && rsa->d != NULL && rsa->d->d != NULL)
339                 {
340                 /* if PRNG is not properly seeded, resort to secret exponent as unpredictable seed */
341                 RAND_add(rsa->d->d, rsa->d->dmax * sizeof rsa->d->d[0], 0);
342                 if (!BN_pseudo_rand_range(A,rsa->n)) goto err;
343                 }
344         else
345                 {
346                 if (!BN_rand_range(A,rsa->n)) goto err;
347                 }
348         if ((Ai=BN_mod_inverse(NULL,A,rsa->n,ctx)) == NULL) goto err;
349
350         if (!rsa->meth->bn_mod_exp(A,A,rsa->e,rsa->n,ctx,rsa->_method_mod_n))
351                 goto err;
352         if ((rsa->blinding=BN_BLINDING_new(A,Ai,rsa->n)) == NULL) goto err;
353         /* to make things thread-safe without excessive locking,
354          * rsa->blinding will be used just by the current thread: */
355         rsa->blinding->thread_id = CRYPTO_thread_id();
356         rsa->flags |= RSA_FLAG_BLINDING;
357         rsa->flags &= ~RSA_FLAG_NO_BLINDING;
358         BN_free(Ai);
359         ret=1;
360 err:
361         BN_CTX_end(ctx);
362         if (ctx != p_ctx) BN_CTX_free(ctx);
363         return(ret);
364         }
365
366 int RSA_memory_lock(RSA *r)
367         {
368         int i,j,k,off;
369         char *p;
370         BIGNUM *bn,**t[6],*b;
371         BN_ULONG *ul;
372
373         if (r->d == NULL) return(1);
374         t[0]= &r->d;
375         t[1]= &r->p;
376         t[2]= &r->q;
377         t[3]= &r->dmp1;
378         t[4]= &r->dmq1;
379         t[5]= &r->iqmp;
380         k=sizeof(BIGNUM)*6;
381         off=k/sizeof(BN_ULONG)+1;
382         j=1;
383         for (i=0; i<6; i++)
384                 j+= (*t[i])->top;
385         if ((p=OPENSSL_malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
386                 {
387                 RSAerr(RSA_F_MEMORY_LOCK,ERR_R_MALLOC_FAILURE);
388                 return(0);
389                 }
390         bn=(BIGNUM *)p;
391         ul=(BN_ULONG *)&(p[off]);
392         for (i=0; i<6; i++)
393                 {
394                 b= *(t[i]);
395                 *(t[i])= &(bn[i]);
396                 memcpy((char *)&(bn[i]),(char *)b,sizeof(BIGNUM));
397                 bn[i].flags=BN_FLG_STATIC_DATA;
398                 bn[i].d=ul;
399                 memcpy((char *)ul,b->d,sizeof(BN_ULONG)*b->top);
400                 ul+=b->top;
401                 BN_clear_free(b);
402                 }
403         
404         /* I should fix this so it can still be done */
405         r->flags&= ~(RSA_FLAG_CACHE_PRIVATE|RSA_FLAG_CACHE_PUBLIC);
406
407         r->bignum_data=p;
408         return(1);
409         }