1ac1331fa4def3b74168991bfb68eab278edb1b4
[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
66 const char *RSA_version="RSA" OPENSSL_VERSION_PTEXT;
67
68 static RSA_METHOD *default_RSA_meth=NULL;
69 static int rsa_meth_num=0;
70 static STACK *rsa_meth=NULL;
71
72 RSA *RSA_new(void)
73         {
74         return(RSA_new_method(NULL));
75         }
76
77 void RSA_set_default_method(RSA_METHOD *meth)
78         {
79         default_RSA_meth=meth;
80         }
81
82 RSA *RSA_new_method(RSA_METHOD *meth)
83         {
84         RSA *ret;
85
86         if (default_RSA_meth == NULL)
87                 {
88 #ifdef RSAref
89                 default_RSA_meth=RSA_PKCS1_RSAref();
90 #else
91                 default_RSA_meth=RSA_PKCS1_SSLeay();
92 #endif
93                 }
94         ret=(RSA *)Malloc(sizeof(RSA));
95         if (ret == NULL)
96                 {
97                 RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE);
98                 return(NULL);
99                 }
100
101         if (meth == NULL)
102                 ret->meth=default_RSA_meth;
103         else
104                 ret->meth=meth;
105
106         ret->pad=0;
107         ret->version=0;
108         ret->n=NULL;
109         ret->e=NULL;
110         ret->d=NULL;
111         ret->p=NULL;
112         ret->q=NULL;
113         ret->dmp1=NULL;
114         ret->dmq1=NULL;
115         ret->iqmp=NULL;
116         ret->references=1;
117         ret->_method_mod_n=NULL;
118         ret->_method_mod_p=NULL;
119         ret->_method_mod_q=NULL;
120         ret->blinding=NULL;
121         ret->bignum_data=NULL;
122         ret->flags=ret->meth->flags;
123         if ((ret->meth->init != NULL) && !ret->meth->init(ret))
124                 {
125                 Free(ret);
126                 ret=NULL;
127                 }
128         else
129                 CRYPTO_new_ex_data(rsa_meth,(char *)ret,&ret->ex_data);
130         return(ret);
131         }
132
133 void RSA_free(RSA *r)
134         {
135         int i;
136
137         if (r == NULL) return;
138
139         i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_RSA);
140 #ifdef REF_PRINT
141         REF_PRINT("RSA",r);
142 #endif
143         if (i > 0) return;
144 #ifdef REF_CHECK
145         if (i < 0)
146                 {
147                 fprintf(stderr,"RSA_free, bad reference count\n");
148                 abort();
149                 }
150 #endif
151
152         CRYPTO_free_ex_data(rsa_meth,(char *)r,&r->ex_data);
153
154         if (r->meth->finish != NULL)
155                 r->meth->finish(r);
156
157         if (r->n != NULL) BN_clear_free(r->n);
158         if (r->e != NULL) BN_clear_free(r->e);
159         if (r->d != NULL) BN_clear_free(r->d);
160         if (r->p != NULL) BN_clear_free(r->p);
161         if (r->q != NULL) BN_clear_free(r->q);
162         if (r->dmp1 != NULL) BN_clear_free(r->dmp1);
163         if (r->dmq1 != NULL) BN_clear_free(r->dmq1);
164         if (r->iqmp != NULL) BN_clear_free(r->iqmp);
165         if (r->blinding != NULL) BN_BLINDING_free(r->blinding);
166         if (r->bignum_data != NULL) Free_locked(r->bignum_data);
167         Free(r);
168         }
169
170 int RSA_get_ex_new_index(long argl, char *argp, int (*new_func)(),
171              int (*dup_func)(), void (*free_func)())
172         {
173         rsa_meth_num++;
174         return(CRYPTO_get_ex_new_index(rsa_meth_num-1,
175                 &rsa_meth,argl,argp,new_func,dup_func,free_func));
176         }
177
178 int RSA_set_ex_data(RSA *r, int idx, char *arg)
179         {
180         return(CRYPTO_set_ex_data(&r->ex_data,idx,arg));
181         }
182
183 char *RSA_get_ex_data(RSA *r, int idx)
184         {
185         return(CRYPTO_get_ex_data(&r->ex_data,idx));
186         }
187
188 int RSA_size(RSA *r)
189         {
190         return(BN_num_bytes(r->n));
191         }
192
193 int RSA_public_encrypt(int flen, unsigned char *from, unsigned char *to,
194              RSA *rsa, int padding)
195         {
196         return(rsa->meth->rsa_pub_enc(flen, from, to, rsa, padding));
197         }
198
199 int RSA_private_encrypt(int flen, unsigned char *from, unsigned char *to,
200              RSA *rsa, int padding)
201         {
202         return(rsa->meth->rsa_priv_enc(flen, from, to, rsa, padding));
203         }
204
205 int RSA_private_decrypt(int flen, unsigned char *from, unsigned char *to,
206              RSA *rsa, int padding)
207         {
208         return(rsa->meth->rsa_priv_dec(flen, from, to, rsa, padding));
209         }
210
211 int RSA_public_decrypt(int flen, unsigned char *from, unsigned char *to,
212              RSA *rsa, int padding)
213         {
214         return(rsa->meth->rsa_pub_dec(flen, from, to, rsa, padding));
215         }
216
217 int RSA_flags(RSA *r)
218         {
219         return((r == NULL)?0:r->meth->flags);
220         }
221
222 void RSA_blinding_off(RSA *rsa)
223         {
224         if (rsa->blinding != NULL)
225                 {
226                 BN_BLINDING_free(rsa->blinding);
227                 rsa->blinding=NULL;
228                 }
229         rsa->flags&= ~RSA_FLAG_BLINDING;
230         }
231
232 int RSA_blinding_on(RSA *rsa, BN_CTX *p_ctx)
233         {
234         BIGNUM *A,*Ai;
235         BN_CTX *ctx;
236         int ret=0;
237
238         if (p_ctx == NULL)
239                 {
240                 if ((ctx=BN_CTX_new()) == NULL) goto err;
241                 }
242         else
243                 ctx=p_ctx;
244
245         if (rsa->blinding != NULL)
246                 BN_BLINDING_free(rsa->blinding);
247
248         A= &(ctx->bn[0]);
249         ctx->tos++;
250         if (!BN_rand(A,BN_num_bits(rsa->n)-1,1,0)) goto err;
251         if ((Ai=BN_mod_inverse(NULL,A,rsa->n,ctx)) == NULL) goto err;
252
253         if (!rsa->meth->bn_mod_exp(A,A,rsa->e,rsa->n,ctx,rsa->_method_mod_n))
254             goto err;
255         rsa->blinding=BN_BLINDING_new(A,Ai,rsa->n);
256         ctx->tos--;
257         rsa->flags|=RSA_FLAG_BLINDING;
258         BN_free(Ai);
259         ret=1;
260 err:
261         if (ctx != p_ctx) BN_CTX_free(ctx);
262         return(ret);
263         }
264
265 int RSA_memory_lock(RSA *r)
266         {
267         int i,j,k,off;
268         char *p;
269         BIGNUM *bn,**t[6],*b;
270         BN_ULONG *ul;
271
272         if (r->d == NULL) return(1);
273         t[0]= &r->d;
274         t[1]= &r->p;
275         t[2]= &r->q;
276         t[3]= &r->dmp1;
277         t[4]= &r->dmq1;
278         t[5]= &r->iqmp;
279         k=sizeof(BIGNUM)*6;
280         off=k/sizeof(BN_ULONG)+1;
281         j=1;
282         for (i=0; i<6; i++)
283                 j+= (*t[i])->top;
284         if ((p=Malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
285                 {
286                 RSAerr(RSA_F_MEMORY_LOCK,ERR_R_MALLOC_FAILURE);
287                 return(0);
288                 }
289         bn=(BIGNUM *)p;
290         ul=(BN_ULONG *)&(p[off]);
291         for (i=0; i<6; i++)
292                 {
293                 b= *(t[i]);
294                 *(t[i])= &(bn[i]);
295                 memcpy((char *)&(bn[i]),(char *)b,sizeof(BIGNUM));
296                 bn[i].flags=BN_FLG_STATIC_DATA;
297                 bn[i].d=ul;
298                 memcpy((char *)ul,b->d,sizeof(BN_ULONG)*b->top);
299                 ul+=b->top;
300                 BN_clear_free(b);
301                 }
302         
303         /* I should fix this so it can still be done */
304         r->flags&= ~(RSA_FLAG_CACHE_PRIVATE|RSA_FLAG_CACHE_PUBLIC);
305
306         r->bignum_data=p;
307         return(1);
308         }
309